public void testIndexMapRemove() {
    final ODocument docOne = new ODocument();
    docOne.save();

    final ODocument docTwo = new ODocument();
    docTwo.save();

    final ODocument docThree = new ODocument();
    docThree.save();

    Map<String, ORID> map = new HashMap<String, ORID>();

    map.put("key1", docOne.getIdentity());
    map.put("key2", docTwo.getIdentity());

    final ODocument document = new ODocument("LinkMapIndexTestClass");
    document.field("linkMap", map);
    document.save();
    document.delete();

    final List<ODocument> resultByKey =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestKey")).execute();

    Assert.assertNotNull(resultByKey);
    Assert.assertEquals(resultByKey.size(), 0);

    final List<ODocument> resultByValue =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestValue")).execute();

    Assert.assertNotNull(resultByValue);
    Assert.assertEquals(resultByValue.size(), 0);
  }
  @Test
  public void testConvertToDocument() throws Exception {
    IPictogram pictogram = new Pictogram();
    pictogram.setTitle("title");
    pictogram.setFileIdentifier("test.txt");

    ODocument document = repository.convertToDocument(pictogram);

    assertEquals("title", document.field("title"));
    assertEquals("test.txt", document.field("fileIdentifier"));

    // class name should be correct
    assertEquals("Pictogram", document.getClassName());

    // save document to get id
    document.save();
    String id = document.getIdentity().toString();

    // set id and test conversion
    pictogram.setId(id);

    ODocument newDocument = repository.convertToDocument(pictogram);

    assertEquals(document.getIdentity().toString(), newDocument.getIdentity().toString());
  }
Beispiel #3
0
  @Test(dependsOnMethods = "updateCollectionsRemoveWithWhereOperator")
  public void updateMapsWithPutOperatorAndWhere() {

    ODocument doc =
        database
            .command(
                new OCommandSQL(
                    "insert into cluster:default (equaledges, name, properties) values ('no', 'updateMapsWithPutOperatorAndWhere', {} )"))
            .execute();

    Integer records =
        database
            .command(
                new OCommandSQL(
                    "update "
                        + doc.getIdentity()
                        + " put properties = 'one', 'two' where name = 'updateMapsWithPutOperatorAndWhere'"))
            .execute();

    Assert.assertEquals(records.intValue(), 1);

    ODocument loadedDoc = database.load(doc.getIdentity(), "*:-1", true);

    Assert.assertTrue(loadedDoc.field("properties") instanceof Map);

    @SuppressWarnings("unchecked")
    Map<Object, Object> entries = loadedDoc.field("properties");
    Assert.assertEquals(entries.size(), 1);

    Assert.assertNull(entries.get("round"));
    Assert.assertNull(entries.get("blaaa"));

    Assert.assertEquals(entries.get("one"), "two");
  }
  @Test
  public void testOrderByRid() {
    List<ODocument> qResult =
        db.command(new OCommandSQL("select from ridsorttest order by @rid ASC")).execute();
    assertTrue(qResult.size() > 0);

    ODocument prev = qResult.get(0);
    for (int i = 1; i < qResult.size(); i++) {
      assertTrue(prev.getIdentity().compareTo(qResult.get(i).getIdentity()) <= 0);
      prev = qResult.get(i);
    }

    qResult = db.command(new OCommandSQL("select from ridsorttest order by @rid DESC")).execute();
    assertTrue(qResult.size() > 0);

    prev = qResult.get(0);
    for (int i = 1; i < qResult.size(); i++) {
      assertTrue(prev.getIdentity().compareTo(qResult.get(i).getIdentity()) >= 0);
      prev = qResult.get(i);
    }

    qResult =
        db.command(new OCommandSQL("select from ridsorttest where name > 3 order by @rid DESC"))
            .execute();
    assertTrue(qResult.size() > 0);

    prev = qResult.get(0);
    for (int i = 1; i < qResult.size(); i++) {
      assertTrue(prev.getIdentity().compareTo(qResult.get(i).getIdentity()) >= 0);
      prev = qResult.get(i);
    }
  }
  @Override
  public void loadDataModel(ODatabaseDocumentTx db) {
    if (piutang != null) {
      if (paging != null) {
        int tmp = paging.getCurentHalaman() - 1 * paging.getJumlahPerHalaman();
        if (tmp < 0) {
          tmp = 0;
        }

        model =
            dao.getAllByColumn(
                db, PiutangdDao.piutang, piutang.getIdentity(), tmp, paging.getJumlahPerHalaman());

        //				pelanggans=new ArrayList<ODocument>();
        //				for (ODocument oDocument : model) {
        //					ODocument tmp2=oDocument.field(PenjualanDao.pelanggan);
        //					tmp2.field(PelangganDao.name);
        //					pelanggans.add(tmp2);
        //				}

      } else {
        model =
            (List<ODocument>)
                getDao().getAllByColumn(db, PiutangdDao.piutang, piutang.getIdentity());
      }
    } else {
      model = new ArrayList<ODocument>();
    }
  }
Beispiel #6
0
  @Test
  @SuppressWarnings("unchecked")
  public void insertList() {
    database.open("admin", "admin");

    ODocument doc =
        (ODocument)
            database
                .command(
                    new OCommandSQL(
                        "insert into cluster:default (equaledges, name, list) values ('yes', 'square', ['bottom', 'top','left','right'] )"))
                .execute();

    Assert.assertTrue(doc != null);

    doc = (ODocument) new ODocument(doc.getIdentity()).load();

    Assert.assertEquals(doc.field("equaledges"), "yes");
    Assert.assertEquals(doc.field("name"), "square");
    Assert.assertTrue(doc.field("list") instanceof List);

    List<Object> entries = ((List<Object>) doc.field("list"));
    Assert.assertEquals(entries.size(), 4);

    Assert.assertEquals(entries.get(0), "bottom");
    Assert.assertEquals(entries.get(1), "top");
    Assert.assertEquals(entries.get(2), "left");
    Assert.assertEquals(entries.get(3), "right");

    database.delete(doc);

    doc =
        (ODocument)
            database
                .command(
                    new OCommandSQL(
                        "insert into cluster:default SET equaledges = 'yes', name = 'square', list = ['bottom', 'top','left','right'] "))
                .execute();

    Assert.assertTrue(doc != null);

    doc = (ODocument) new ODocument(doc.getIdentity()).load();

    Assert.assertEquals(doc.field("equaledges"), "yes");
    Assert.assertEquals(doc.field("name"), "square");
    Assert.assertTrue(doc.field("list") instanceof List);

    entries = ((List<Object>) doc.field("list"));
    Assert.assertEquals(entries.size(), 4);

    Assert.assertEquals(entries.get(0), "bottom");
    Assert.assertEquals(entries.get(1), "top");
    Assert.assertEquals(entries.get(2), "left");
    Assert.assertEquals(entries.get(3), "right");

    database.close();
  }
  @Test
  public void testFindByParent() throws Exception {
    ODocument parent1 =
        new ODocument("Node")
            .field("title", "ref1")
            .field("titleasc", "ref1")
            .field("description", "desc")
            .field("descriptionMarkup", "default")
            .field("created", 1L)
            .field("modified", 2L);
    parent1.save();
    ODocument parent2 =
        new ODocument("Node")
            .field("title", "ref2")
            .field("titleasc", "ref2")
            .field("description", "desc")
            .field("descriptionMarkup", "default")
            .field("created", 1L)
            .field("modified", 2L);
    parent2.save();

    String id1 = parent1.getIdentity().toString();
    String id2 = parent2.getIdentity().toString();

    IPeriod period1 = new Period();
    period1.setFromEntry("1.1585");
    period1.setToEntry("2.1585");
    period1.setCreated(1L);
    period1.setModified(2L);
    period1.setParentId(id1);
    repository.save(period1);

    IPeriod period2 = new Period();
    period2.setFromEntry("1929");
    period2.setToEntry("1930");
    period2.setCreated(1L);
    period2.setModified(2L);
    period2.setParentId(id1);
    repository.save(period2);

    IPeriod period3 = new Period();
    period3.setFromEntry("1.1.1700");
    period3.setToEntry("5.6.1702");
    period3.setCreated(1L);
    period3.setModified(2L);
    period3.setParentId(id1);
    repository.save(period3);

    List<IPeriod> periods = repository.findByParent(id1);

    assertTrue(periods.size() == 3);

    periods = repository.findByParent(id2);
    assertTrue(periods.size() == 0);
  }
  public void testIndexMapUpdateOneTx() throws Exception {
    final ODocument docOne = new ODocument();
    docOne.save();

    final ODocument docTwo = new ODocument();
    docTwo.save();

    database.begin();
    try {
      final Map<String, ORID> mapTwo = new HashMap<String, ORID>();

      mapTwo.put("key3", docOne.getIdentity());
      mapTwo.put("key2", docTwo.getIdentity());

      final ODocument document = new ODocument("LinkMapIndexTestClass");
      document.field("linkMap", mapTwo);
      document.save();

      database.commit();
    } catch (Exception e) {
      database.rollback();
      throw e;
    }

    final List<ODocument> resultByKey =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestKey")).execute();

    Assert.assertNotNull(resultByKey);
    Assert.assertEquals(resultByKey.size(), 2);
    for (ODocument d : resultByKey) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals("key2") && !d.field("key").equals("key3")) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }

    final List<ODocument> resultByValue =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestValue")).execute();

    Assert.assertNotNull(resultByValue);
    Assert.assertEquals(resultByValue.size(), 2);
    for (ODocument d : resultByValue) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals(docOne.getIdentity())
          && !d.field("key").equals(docTwo.getIdentity())) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }
  }
Beispiel #9
0
  @Test
  @SuppressWarnings("unchecked")
  public void insertMap() {
    database.open("admin", "admin");

    ODocument doc =
        (ODocument)
            database
                .command(
                    new OCommandSQL(
                        "insert into cluster:default (equaledges, name, properties) values ('no', 'circle', {'round':'eeee', 'blaaa':'zigzag'} )"))
                .execute();

    Assert.assertTrue(doc != null);

    doc = (ODocument) new ODocument(doc.getIdentity()).load();

    Assert.assertEquals(doc.field("equaledges"), "no");
    Assert.assertEquals(doc.field("name"), "circle");
    Assert.assertTrue(doc.field("properties") instanceof Map);

    Map<Object, Object> entries = ((Map<Object, Object>) doc.field("properties"));
    Assert.assertEquals(entries.size(), 2);

    Assert.assertEquals(entries.get("round"), "eeee");
    Assert.assertEquals(entries.get("blaaa"), "zigzag");

    database.delete(doc);

    doc =
        (ODocument)
            database
                .command(
                    new OCommandSQL(
                        "insert into cluster:default SET equaledges = 'no', name = 'circle', properties = {'round':'eeee', 'blaaa':'zigzag'} "))
                .execute();

    Assert.assertTrue(doc != null);

    doc = (ODocument) new ODocument(doc.getIdentity()).load();

    Assert.assertEquals(doc.field("equaledges"), "no");
    Assert.assertEquals(doc.field("name"), "circle");
    Assert.assertTrue(doc.field("properties") instanceof Map);

    entries = ((Map<Object, Object>) doc.field("properties"));
    Assert.assertEquals(entries.size(), 2);

    Assert.assertEquals(entries.get("round"), "eeee");
    Assert.assertEquals(entries.get("blaaa"), "zigzag");
    database.close();
  }
  @SuppressWarnings("unchecked")
  @Test
  public void loadRecordTest() {
    ODatabaseDocumentTx db = new ODatabaseDocumentTx(url);
    db.open("admin", "admin");

    try {
      db.begin();

      ODocument kim = new ODocument("Profile").field("name", "Kim").field("surname", "Bauer");
      ODocument teri = new ODocument("Profile").field("name", "Teri").field("surname", "Bauer");
      ODocument jack = new ODocument("Profile").field("name", "Jack").field("surname", "Bauer");
      ODocument chloe = new ODocument("Profile").field("name", "Chloe").field("surname", "O'Brien");

      ((HashSet<ODocument>) jack.field("following", new HashSet<ODocument>()).field("following"))
          .add(kim);
      ((HashSet<ODocument>) kim.field("following", new HashSet<ODocument>()).field("following"))
          .add(teri);
      ((HashSet<ODocument>) teri.field("following", new HashSet<ODocument>()).field("following"))
          .add(jack);
      ((HashSet<ODocument>) teri.field("following")).add(kim);
      ((HashSet<ODocument>) chloe.field("following", new HashSet<ODocument>()).field("following"))
          .add(jack);
      ((HashSet<ODocument>) chloe.field("following")).add(teri);
      ((HashSet<ODocument>) chloe.field("following")).add(kim);

      int profileClusterId = db.getClusterIdByName("Profile");

      jack.save();
      Assert.assertEquals(jack.getIdentity().getClusterId(), profileClusterId);

      kim.save();
      Assert.assertEquals(kim.getIdentity().getClusterId(), profileClusterId);

      teri.save();
      Assert.assertEquals(teri.getIdentity().getClusterId(), profileClusterId);

      chloe.save();
      Assert.assertEquals(chloe.getIdentity().getClusterId(), profileClusterId);

      db.commit();

      Assert.assertEquals(jack.getIdentity().getClusterId(), profileClusterId);
      Assert.assertEquals(kim.getIdentity().getClusterId(), profileClusterId);
      Assert.assertEquals(teri.getIdentity().getClusterId(), profileClusterId);
      Assert.assertEquals(chloe.getIdentity().getClusterId(), profileClusterId);

      db.close();
      db.open("admin", "admin");

      ODocument loadedChloe = db.load(chloe.getIdentity());
      System.out.println(loadedChloe);
    } finally {
      db.close();
    }
  }
    @Override
    public Void call() throws Exception {
      baseDB.open("admin", "admin");
      testDB.open("admin", "admin");

      try {
        while (true) {
          long id = idGen.getAndIncrement();
          long ts = System.currentTimeMillis();

          ODatabaseRecordThreadLocal.INSTANCE.set(baseDB);

          ODocument doc = new ODocument();
          doc.field("ts", ts);
          doc.save();

          baseDB
              .command(
                  new OCommandSQL(
                      "insert into index:mi (key, rid) values ("
                          + id
                          + ", "
                          + doc.getIdentity()
                          + ")"))
              .execute();

          ODatabaseRecordThreadLocal.INSTANCE.set(testDB);
          doc = new ODocument();
          doc.field("ts", ts);
          doc.save();

          testDB
              .command(
                  new OCommandSQL(
                      "insert into index:mi (key, rid) values ("
                          + id
                          + ", "
                          + doc.getIdentity()
                          + ")"))
              .execute();
        }
      } finally {
        baseDB.activateOnCurrentThread();
        baseDB.close();

        testDB.activateOnCurrentThread();
        testDB.close();
      }
    }
  @Test
  public void testConvertToEntity() throws Exception {
    ODocument parent =
        new ODocument("Node")
            .field("title", "ref1")
            .field("titleasc", "ref1")
            .field("description", "desc")
            .field("descriptionMarkup", "default")
            .field("created", 1L)
            .field("modified", 2L);
    parent.save();

    ODocument document =
        new ODocument("Period")
            .field("fromEntryCalendar", "G")
            .field("toEntryCalendar", "G")
            .field("fromEntry", "1.1585")
            .field("toEntry", "2.1585")
            .field("from", 2299970L)
            .field("to", 2300028L)
            .field("type", "period")
            .field("comment", "comment")
            .field("fromFuzzyFlags", "x?")
            .field("toFuzzyFlags", "c?")
            .field("parent", parent)
            .field("created", 1L)
            .field("modified", 2L);
    // persist to database to create id
    document.save();

    IPeriod period = repository.convertToEntity(document);

    assertEquals("1.1585", period.getFromEntry());
    assertEquals("2.1585", period.getToEntry());
    assertEquals("G", period.getFromEntryCalendar());
    assertEquals("G", period.getToEntryCalendar());
    assertEquals("period", period.getType());
    assertEquals(new Long(2299970L), period.getFromJD());
    assertEquals(new Long(2300028L), period.getToJD());
    assertEquals("comment", period.getComment());
    assertArrayEquals(new char[] {'?'}, period.getFuzzyFromFlags());
    assertArrayEquals(new char[] {'c', '?'}, period.getFuzzyToFlags());
    assertEquals(new Long(1L), period.getCreated());
    assertEquals(new Long(2L), period.getModified());
    assertEquals(parent.getIdentity().toString(), period.getParentId());
    assertEquals("Node", period.getParentModel());
    assertEquals(document.getIdentity().toString(), period.getId());
  }
Beispiel #13
0
 private static void fetchArray(
     final ORecordSchemaAware<?> iRootRecord,
     final Object iUserObject,
     final Map<String, Integer> iFetchPlan,
     Object fieldValue,
     String fieldName,
     final int iCurrentLevel,
     final int iLevelFromRoot,
     final int iFieldDepthLevel,
     final Map<ORID, Integer> parsedRecords,
     final String iFieldPathFromRoot,
     final OFetchListener iListener,
     final OFetchContext iContext)
     throws IOException {
   if (fieldValue instanceof ODocument[]) {
     final ODocument[] linked = (ODocument[]) fieldValue;
     iContext.onBeforeArray(iRootRecord, fieldName, iUserObject, linked);
     for (ODocument d : linked) {
       // GO RECURSIVELY
       final Integer fieldDepthLevel = parsedRecords.get(d.getIdentity());
       if (!d.getIdentity().isValid()
           || (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) {
         removeParsedFromMap(parsedRecords, d);
         iContext.onBeforeDocument(iRootRecord, d, fieldName, iUserObject);
         final Object userObject =
             iListener.fetchLinked(iRootRecord, iUserObject, fieldName, d, iContext);
         processRecord(
             d,
             userObject,
             iFetchPlan,
             iCurrentLevel,
             iLevelFromRoot,
             iFieldDepthLevel,
             parsedRecords,
             iFieldPathFromRoot,
             iListener,
             iContext,
             "");
         iContext.onAfterDocument(iRootRecord, d, fieldName, iUserObject);
       } else {
         iListener.parseLinkedCollectionValue(iRootRecord, d, iUserObject, fieldName, iContext);
       }
     }
     iContext.onAfterArray(iRootRecord, fieldName, iUserObject);
   } else {
     iListener.processStandardField(iRootRecord, fieldValue, fieldName, iContext, iUserObject, "");
   }
 }
  @Test
  public void test5CacheUpdatedMultipleDbs() {
    database1 = new ODatabaseDocumentTx(url).open("admin", "admin");
    database2 = new ODatabaseDocumentTx(url).open("admin", "admin");

    // Create docA in db1
    database1.begin(TXTYPE.OPTIMISTIC);
    ODocument vDocA_db1 = database1.newInstance();
    vDocA_db1.field(NAME, "docA");
    database1.save(vDocA_db1);
    database1.commit();

    // Keep the ID.
    ORID vDocA_Rid = vDocA_db1.getIdentity().copy();

    // Update docA in db2
    database2.begin(TXTYPE.OPTIMISTIC);
    ODocument vDocA_db2 = database2.load(vDocA_Rid);
    vDocA_db2.field(NAME, "docA_v2");
    database2.save(vDocA_db2);
    database2.commit();

    // Later... read docA with db1.
    database1.begin(TXTYPE.OPTIMISTIC);
    ODocument vDocA_db1_later = database1.load(vDocA_Rid, null, true);
    Assert.assertEquals(vDocA_db1_later.field(NAME), "docA_v2");
    database1.commit();

    database1.close();
    database2.close();
  }
 @Override
 public OSerializableStream fromStream(final byte[] iStream) throws OSerializationException {
   final ODocument record = getRecord();
   ((ORecordId) record.getIdentity()).fromString(new String(iStream));
   record.setInternalStatus(STATUS.NOT_LOADED);
   return this;
 }
  /**
   * helper to load nodes relation to document
   *
   * @param document relationLink document/link
   * @param direction "in" or "out"
   * @return INode instance or null
   */
  private @Nullable INode getRelatedEntity(ODocument document, String direction) {
    Object nodeO = document.field(direction, ORecordId.class);
    if (nodeO == null) {
      logger.error(
          "Could not create related entity while converting relation with direction " + direction);
      return null;
    }
    if (nodeO instanceof ORecordId) nodeO = repositoryFactory.getDb().load((ORecordId) nodeO);
    if (nodeO == null) {
      logger.error("Invalid record in direction " + direction + ": " + document.toString());
      return null;
    }

    // convert
    ODocument nodeDoc = (ODocument) nodeO;

    // slim node: just set title and id
    INode node = new Node();
    node.setTitle(nodeDoc.field("title"));
    node.setId(nodeDoc.getIdentity().toString());

    return node;

    /*
    old -not performant
    String id;
    if (relationO instanceof OIdentifiable) id = ((ORecordId)relationO).getIdentity().toString();
    else {
    	logger.error("Invalid class type: " + relationO.getClass().getName());
    	return null;
    }

    return nodeRepository.find(id);*/
  }
Beispiel #17
0
  public void testAutoConversionOfEmbeddededListWithLinkedClass() {
    OClass c = database.getMetadata().getSchema().getOrCreateClass("TestConvert");
    if (!c.existsProperty("embeddedListWithLinkedClass"))
      c.createProperty(
          "embeddedListWithLinkedClass",
          OType.EMBEDDEDLIST,
          database.getMetadata().getSchema().getOrCreateClass("TestConvertLinkedClass"));

    ODocument doc =
        database
            .command(
                new OCommandSQL(
                    "INSERT INTO TestConvert SET name = 'embeddedListWithLinkedClass', embeddedListWithLinkedClass = [{'line1':'123 Fake Street'}]"))
            .execute();

    database
        .command(
            new OCommandSQL(
                "UPDATE "
                    + doc.getIdentity()
                    + " ADD embeddedListWithLinkedClass = [{'line1':'123 Fake Street'}]"))
        .execute();

    doc.reload();

    Assert.assertTrue(doc.field("embeddedListWithLinkedClass") instanceof List);
    Assert.assertEquals(((Collection) doc.field("embeddedListWithLinkedClass")).size(), 2);

    database
        .command(
            new OCommandSQL(
                "UPDATE "
                    + doc.getIdentity()
                    + " ADD embeddedListWithLinkedClass = {'line1':'123 Fake Street'}"))
        .execute();

    doc.reload();

    Assert.assertTrue(doc.field("embeddedListWithLinkedClass") instanceof List);
    Assert.assertEquals(((Collection) doc.field("embeddedListWithLinkedClass")).size(), 3);

    List addr = doc.field("embeddedListWithLinkedClass");
    for (Object o : addr) {
      Assert.assertTrue(o instanceof ODocument);
      Assert.assertEquals(((ODocument) o).getClassName(), "TestConvertLinkedClass");
    }
  }
Beispiel #18
0
 private static void updateRidMap(
     final Map<String, Integer> iFetchPlan,
     final ODocument fieldValue,
     final int iCurrentLevel,
     final int iLevelFromRoot,
     final int iFieldDepthLevel,
     final Map<ORID, Integer> parsedRecords,
     final String iFieldPathFromRoot,
     final OFetchContext iContext)
     throws IOException {
   final Integer fetchedLevel = parsedRecords.get(fieldValue.getIdentity());
   int currentLevel = iCurrentLevel + 1;
   int fieldDepthLevel = iFieldDepthLevel;
   if (iFetchPlan.containsKey(iFieldPathFromRoot)) {
     currentLevel = 1;
     fieldDepthLevel = iFetchPlan.get(iFieldPathFromRoot);
   }
   if (fetchedLevel == null) {
     if (!fieldValue.isEmbedded()) {
       parsedRecords.put(fieldValue.getIdentity(), iLevelFromRoot);
     }
     processRecordRidMap(
         fieldValue,
         iFetchPlan,
         currentLevel,
         iLevelFromRoot,
         fieldDepthLevel,
         parsedRecords,
         iFieldPathFromRoot,
         iContext);
   } else if ((!fieldValue.getIdentity().isValid() && fetchedLevel < iLevelFromRoot)
       || fetchedLevel > iLevelFromRoot) {
     if (!fieldValue.isEmbedded()) {
       parsedRecords.put(fieldValue.getIdentity(), iLevelFromRoot);
     }
     processRecordRidMap(
         (ODocument) fieldValue,
         iFetchPlan,
         currentLevel,
         iLevelFromRoot,
         fieldDepthLevel,
         parsedRecords,
         iFieldPathFromRoot,
         iContext);
   }
 }
  @SuppressWarnings("unchecked")
  @Test
  public void checkVersionsInConnectedDocuments() {
    ODatabaseDocumentTx db = new ODatabaseDocumentTx(url);
    db.open("admin", "admin");

    db.begin();

    ODocument kim = new ODocument("Profile").field("name", "Kim").field("surname", "Bauer");
    ODocument teri = new ODocument("Profile").field("name", "Teri").field("surname", "Bauer");
    ODocument jack = new ODocument("Profile").field("name", "Jack").field("surname", "Bauer");

    ((HashSet<ODocument>) jack.field("following", new HashSet<ODocument>()).field("following"))
        .add(kim);
    ((HashSet<ODocument>) kim.field("following", new HashSet<ODocument>()).field("following"))
        .add(teri);
    ((HashSet<ODocument>) teri.field("following", new HashSet<ODocument>()).field("following"))
        .add(jack);

    jack.save();

    db.commit();

    db.close();
    db.open("admin", "admin");

    ODocument loadedJack = db.load(jack.getIdentity());

    ORecordVersion jackLastVersion = loadedJack.getRecordVersion().copy();
    db.begin();
    loadedJack.field("occupation", "agent");
    loadedJack.save();
    db.commit();
    Assert.assertTrue(!jackLastVersion.equals(loadedJack.getRecordVersion()));

    loadedJack = db.load(jack.getIdentity());
    Assert.assertTrue(!jackLastVersion.equals(loadedJack.getRecordVersion()));

    db.close();

    db.open("admin", "admin");
    loadedJack = db.load(jack.getIdentity());
    Assert.assertTrue(!jackLastVersion.equals(loadedJack.getRecordVersion()));
    db.close();
  }
  public void testIndexMap() {
    final ODocument docOne = new ODocument();
    docOne.save();

    final ODocument docTwo = new ODocument();
    docTwo.save();

    Map<String, ORID> map = new HashMap<String, ORID>();

    map.put("key1", docOne.getIdentity());
    map.put("key2", docTwo.getIdentity());

    final ODocument document = new ODocument("LinkMapIndexTestClass");
    document.field("linkMap", map);
    document.save();

    final List<ODocument> resultByKey =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestKey")).execute();

    Assert.assertNotNull(resultByKey);
    Assert.assertEquals(resultByKey.size(), 2);
    for (ODocument d : resultByKey) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals("key1") && !d.field("key").equals("key2")) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }

    final List<ODocument> resultByValue =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestValue")).execute();

    Assert.assertNotNull(resultByValue);
    Assert.assertEquals(resultByValue.size(), 2);
    for (ODocument d : resultByValue) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals(docOne.getIdentity())
          && !d.field("key").equals(docTwo.getIdentity())) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }
  }
  public void testIndexMapRemoveItemInTxRollback() throws Exception {
    final ODocument docOne = new ODocument();
    docOne.save();

    final ODocument docTwo = new ODocument();
    docTwo.save();

    final ODocument docThree = new ODocument();
    docThree.save();

    Map<String, ORID> map = new HashMap<String, ORID>();

    map.put("key1", docOne.getIdentity());
    map.put("key2", docTwo.getIdentity());
    map.put("key3", docThree.getIdentity());

    final ODocument document = new ODocument("LinkMapIndexTestClass");
    document.field("linkMap", map);
    document.save();

    database.begin();
    final ODocument loadedDocument = database.load(document.getIdentity());
    loadedDocument.<Map<String, ORID>>field("linkMap").remove("key2");
    loadedDocument.save();
    database.rollback();

    final List<ODocument> resultByKey =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestKey")).execute();

    Assert.assertNotNull(resultByKey);
    Assert.assertEquals(resultByKey.size(), 3);
    for (ODocument d : resultByKey) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals("key1")
          && !d.field("key").equals("key2")
          && !d.field("key").equals("key3")) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }

    final List<ODocument> resultByValue =
        database.command(new OCommandSQL("select key, rid from index:mapIndexTestValue")).execute();

    Assert.assertNotNull(resultByValue);
    Assert.assertEquals(resultByValue.size(), 3);
    for (ODocument d : resultByValue) {
      Assert.assertTrue(d.containsField("key"));
      Assert.assertTrue(d.containsField("rid"));

      if (!d.field("key").equals(docOne.getIdentity())
          && !d.field("key").equals(docTwo.getIdentity())
          && !d.field("key").equals(docThree.getIdentity())) {
        Assert.fail("Unknown key found: " + d.field("key"));
      }
    }
  }
  /**
   * Deletes the specified object from the object set.
   *
   * <p>{@inheritDoc}
   *
   * @throws NotFoundException if the specified object could not be found.
   * @throws ForbiddenException if access to the object is forbidden.
   * @throws ConflictException if version is required but is {@code null}.
   * @throws PreconditionFailedException if version did not match the existing object in the set.
   */
  @Override
  public ResourceResponse delete(DeleteRequest request) throws ResourceException {
    if (request.getResourcePathObject().size() < 2) {
      throw new NotFoundException(
          "The object identifier did not include sufficient information to determine the object type and identifier of the object to update: "
              + request.getResourcePath());
    }

    if (request.getRevision() == null || "".equals(request.getRevision())) {
      throw new ConflictException(
          "Object passed into delete does not have revision it expects set.");
    }

    final String type = request.getResourcePathObject().parent().toString();
    final String localId = request.getResourcePathObject().leaf();

    int ver =
        DocumentUtil.parseVersion(
            request.getRevision()); // This throws ConflictException if parse fails

    ODatabaseDocumentTx db = getConnection();
    try {
      ODocument existingDoc = predefinedQueries.getByID(localId, type, db);
      if (existingDoc == null) {
        throw new NotFoundException(
            "Object does not exist for delete on: " + request.getResourcePath());
      }

      db.delete(existingDoc.getIdentity(), new OSimpleVersion(ver));
      logger.debug("delete for id succeeded: {} revision: {}", localId, request.getRevision());
      return DocumentUtil.toResource(existingDoc);
    } catch (ODatabaseException ex) {
      // Without transaction the concurrent modification exception gets nested instead
      if (isCauseConcurrentModificationException(ex, 10)) {
        throw new PreconditionFailedException(
            "Delete rejected as current Object revision is different than expected by caller, the object has changed since retrieval. "
                + ex.getMessage(),
            ex);
      } else {
        throw ex;
      }

    } catch (OConcurrentModificationException ex) {
      throw new PreconditionFailedException(
          "Delete rejected as current Object revision is different than expected by caller, the object has changed since retrieval."
              + ex.getMessage(),
          ex);
    } catch (RuntimeException e) {
      throw e;
    } finally {
      if (db != null) {
        db.close();
      }
    }
  }
Beispiel #23
0
  @Test(dependsOnMethods = "updateCollectionsRemoveWithWhereOperator")
  public void updateCollectionsWithSetOperator() {

    List<ODocument> docs = database.query(new OSQLSynchQuery<ODocument>("select from Account"));

    List<Long> positions = getValidPositions(addressClusterId);

    for (ODocument doc : docs) {

      final int records =
          database
              .command(
                  new OCommandSQL(
                      "update Account set addresses = [#"
                          + addressClusterId
                          + ":"
                          + positions.get(0)
                          + ", #"
                          + addressClusterId
                          + ":"
                          + positions.get(1)
                          + ",#"
                          + addressClusterId
                          + ":"
                          + positions.get(2)
                          + "] where @rid = "
                          + doc.getIdentity()))
              .execute();

      Assert.assertEquals(records, 1);

      ODocument loadedDoc = database.load(doc.getIdentity(), "*:-1", true);
      Assert.assertEquals(((List<?>) loadedDoc.field("addresses")).size(), 3);
      Assert.assertEquals(
          ((OIdentifiable) ((List<?>) loadedDoc.field("addresses")).get(0))
              .getIdentity()
              .toString(),
          "#" + addressClusterId + ":" + positions.get(0));
      loadedDoc.field("addresses", doc.field("addresses"));
      database.save(loadedDoc);
    }
  }
  private void create() {
    for (int i = 0; i < ITERATIONS; ++i) {
      final int selectedClusterId =
          clusterIds[((int) (Math.abs(hashFunction.hashCode(i)) % clusterIds.length))];

      ODocument sqlRecord =
          database
              .command(new OCommandSQL("insert into AutoShardingTest (id) values (" + i + ")"))
              .execute();
      Assert.assertEquals(sqlRecord.getIdentity().getClusterId(), selectedClusterId);

      ODocument apiRecord = new ODocument("AutoShardingTest").field("id", i).save();
      Assert.assertEquals(apiRecord.getIdentity().getClusterId(), selectedClusterId);
    }

    // TEST ALL CLUSTER HAVE RECORDS
    for (int clusterId : cls.getClusterIds()) {
      Assert.assertTrue(database.countClusterElements(clusterId) > 0);
    }
  }
  @Test
  public void testUnwindOrder() {
    List<ODocument> qResult =
        db.command(new OCommandSQL("select from unwindtest order by coll unwind coll")).execute();

    assertEquals(qResult.size(), 4);
    for (ODocument doc : qResult) {
      String name = doc.field("name");
      String coll = doc.field("coll");
      assertTrue(coll.startsWith(name));
      assertFalse(doc.getIdentity().isPersistent());
    }
  }
Beispiel #26
0
  private List<Long> getValidPositions(int clusterId) {
    final List<Long> positions = new ArrayList<Long>();

    final ORecordIteratorCluster<ODocument> iteratorCluster =
        database.browseCluster(database.getClusterNameById(clusterId));

    for (int i = 0; i < 7; i++) {
      if (!iteratorCluster.hasNext()) break;
      ODocument doc = iteratorCluster.next();
      positions.add(doc.getIdentity().getClusterPosition());
    }
    return positions;
  }
  @Test
  public void test3RollbackWithCopyCacheStrategy() throws IOException {
    database1 = new ODatabaseDocumentTx(url).open("admin", "admin");
    database2 = new ODatabaseDocumentTx(url).open("admin", "admin");

    database1.getLevel2Cache().setStrategy(STRATEGY.COPY_RECORD);

    // Create docA.
    ODocument vDocA_db1 = database1.newInstance();
    vDocA_db1.field(NAME, "docA");
    database1.save(vDocA_db1);

    // Keep the IDs.
    ORID vDocA_Rid = vDocA_db1.getIdentity().copy();

    database2.begin(TXTYPE.OPTIMISTIC);
    try {
      // Get docA and update in db2 transaction context
      ODocument vDocA_db2 = database2.load(vDocA_Rid);
      vDocA_db2.field(NAME, "docA_v2");
      database2.save(vDocA_db2);

      database1.begin(TXTYPE.OPTIMISTIC);
      try {
        vDocA_db1.field(NAME, "docA_v3");
        database1.save(vDocA_db1);
        database1.commit();
      } catch (OConcurrentModificationException e) {
        Assert.fail("Should not failed here...");
      }
      Assert.assertEquals(vDocA_db1.field(NAME), "docA_v3");

      // Will throw OConcurrentModificationException
      database2.commit();
      Assert.fail("Should throw OConcurrentModificationException");
    } catch (OConcurrentModificationException e) {
      database2.rollback();
    }

    // Force reload all (to be sure it is not a cache problem)
    database1.close();
    database2.close();
    database2 = new ODatabaseDocumentTx(url).open("admin", "admin");

    // docB should be in the last state : "docA_v3"
    ODocument vDocB_db2 = database2.load(vDocA_Rid);
    Assert.assertEquals(vDocB_db2.field(NAME), "docA_v3");

    database1.close();
    database2.close();
  }
  @Test
  public void testQuery() {
    create();
    for (int i = 0; i < ITERATIONS; ++i) {
      final int selectedClusterId =
          clusterIds[((int) (Math.abs(hashFunction.hashCode(i)) % clusterIds.length))];

      Iterable<ODocument> resultSet =
          database.command(new OCommandSQL("select from AutoShardingTest where id = ?")).execute(i);
      Assert.assertTrue(resultSet.iterator().hasNext());
      final ODocument sqlRecord = resultSet.iterator().next();
      Assert.assertEquals(sqlRecord.getIdentity().getClusterId(), selectedClusterId);
    }
  }
Beispiel #29
0
 public void updateWithReturn() {
   ODocument doc = new ODocument("Data");
   doc.field("name", "Pawel");
   doc.field("city", "Wroclaw");
   doc.field("really_big_field", "BIIIIIIIIIIIIIIIGGGGGGG!!!");
   doc.save();
   // check AFTER
   String sqlString = "UPDATE " + doc.getIdentity().toString() + " SET gender='male' RETURN AFTER";
   List<ODocument> result1 = database.command(new OCommandSQL(sqlString)).execute();
   Assert.assertEquals(result1.size(), 1);
   Assert.assertEquals(result1.get(0).getIdentity(), doc.getIdentity());
   Assert.assertEquals((String) result1.get(0).field("gender"), "male");
   final ODocument lastOne = result1.get(0).copy();
   // check record attributes and BEFORE
   sqlString = "UPDATE " + doc.getIdentity().toString() + " SET Age=1 RETURN BEFORE @this";
   result1 = database.command(new OCommandSQL(sqlString)).execute();
   Assert.assertEquals(result1.size(), 1);
   Assert.assertEquals(lastOne.getVersion(), result1.get(0).getVersion());
   Assert.assertFalse(result1.get(0).containsField("Age"));
   // check INCREMENT, AFTER + $current + field
   sqlString =
       "UPDATE " + doc.getIdentity().toString() + " INCREMENT Age = 100 RETURN AFTER $current.Age";
   result1 = database.command(new OCommandSQL(sqlString)).execute();
   Assert.assertEquals(result1.size(), 1);
   Assert.assertTrue(result1.get(0).containsField("value"));
   Assert.assertEquals(result1.get(0).field("value"), 101);
   // check exclude + WHERE + LIMIT
   sqlString =
       "UPDATE "
           + doc.getIdentity().toString()
           + " INCREMENT Age = 100 RETURN AFTER $current.Exclude('really_big_field') WHERE Age=101 LIMIT 1";
   result1 = database.command(new OCommandSQL(sqlString)).execute();
   Assert.assertEquals(result1.size(), 1);
   Assert.assertTrue(result1.get(0).containsField("Age"));
   Assert.assertEquals(result1.get(0).field("Age"), 201);
   Assert.assertFalse(result1.get(0).containsField("really_big_field"));
 }
Beispiel #30
0
  @Test(dependsOnMethods = "updateCollectionsRemoveWithWhereOperator")
  public void updateMapsWithSetOperator() {

    ODocument doc =
        database
            .command(
                new OCommandSQL(
                    "insert into cluster:default (equaledges, name, properties) values ('no', 'circleUpdate', {'round':'eeee', 'blaaa':'zigzag'} )"))
            .execute();

    Integer records =
        database
            .command(
                new OCommandSQL(
                    "update "
                        + doc.getIdentity()
                        + " set properties = {'roundOne':'ffff', 'bla':'zagzig','testTestTEST':'okOkOK'}"))
            .execute();

    Assert.assertEquals(records.intValue(), 1);

    ODocument loadedDoc = database.load(doc.getIdentity(), "*:-1", true);

    Assert.assertTrue(loadedDoc.field("properties") instanceof Map);

    @SuppressWarnings("unchecked")
    Map<Object, Object> entries = loadedDoc.field("properties");
    Assert.assertEquals(entries.size(), 3);

    Assert.assertNull(entries.get("round"));
    Assert.assertNull(entries.get("blaaa"));

    Assert.assertEquals(entries.get("roundOne"), "ffff");
    Assert.assertEquals(entries.get("bla"), "zagzig");
    Assert.assertEquals(entries.get("testTestTEST"), "okOkOK");
  }