Examples of org.lilyproject.repository.api.Record

org.lilyproject.repository.api.Record
A Record is the core entity managed by the {@link Repository}.
A Record can be instantiated via {@link Repository#newRecord() Repository.newRecord} or retrieved via{@link Repository#read(RecordId) Repository.read}. As all entities within this API, records are dumb data objects.
All Record-related CRUD operations are available on the {@link Repository} interface:{@link Repository#create(Record) Create}, {@link Repository#read(RecordId) Read}, {@link Repository#update(Record) Update}, {@link Repository#delete(RecordId) Delete}.
A Record object is not necessarily a representation of a complete record. When {@link Repository#read(RecordId,java.util.List) reading}a record, you can specify to only read certain fields. Likewise, when {@link Repository#update(Record) updating}, you only need to put the fields in this object that you want to be updated. But it is not necessary to remove unchanged fields from this object, the repository will compare with the current situation and ignore unchanged fields.
Since for an update, this object only needs to contain the fields you want to update, fields that are not in this object will not be automatically removed from the record. Rather, you have to say explicitly which fields should be deleted by adding them to the {@link #getFieldsToDelete() fields-to-delete} list. If thefields-to-delete list contains field names that do not exist in the record, then these will be ignored upon update, rather than causing an exception.
The {@link RecordType} and its version define the schema of the record. As is explained in more detail inLily's repository model documentation, a record has a pointer to three (possibly) different record types, one for each scope.

        rt.addFieldTypeEntry(nvfieldtype.getId(), false);
        rt = typeManager.createRecordType(rt);


        // Create a record with versions
        RecordId recordId = repository.getIdGenerator().newRecordId();
        Record record = repository.newRecord(recordId);
        record.setRecordType(rt.getName());


        record.setField(vfield, "value 1");
        record = repository.createOrUpdate(record);


        record.setField(vfield, "value 2");
        record = repository.createOrUpdate(record);


        assertEquals(2L, record.getVersion().longValue());


        // Delete the record
        repository.delete(recordId);


        // Re-create the record, this time without versions
        record = repository.newRecord(recordId);
        record.setRecordType(rt.getName());
        record.setField(nvfield, "nv value 1");
        record = repository.createOrUpdate(record);


        assertEquals(null, record.getVersion());


        assertEquals(rt.getName(), record.getRecordTypeName());


        // Now add a version again, reusing last value from previously deleted record
        record.setField(vfield, "value 2");
        record = repository.createOrUpdate(record);


        assertEquals(3L, record.getVersion().longValue());
    }

View Full Code Here

        RecordId recordId = null;
        int i = 0;
        try {
            while (true) {
                recordId = repository.getIdGenerator().newRecordId("MyRecord" + i++);
                Record read = repository.read(recordId);
                System.out.println("[KeepDataTest] Record already exists: " + recordId);
            }
        } catch (RecordNotFoundException e) {
            System.out.println("[KeepDataTest] Record does not exist yet. Create it: " + recordId);
            Record record = repository.newRecord(recordId);
            record.setRecordType(RECORDTYPE1);
            record.setField(FIELD1, "name1");
            record = repository.create(record);
        }
        Record record = repository.read(recordId);
        Assert.assertEquals("name1", (String) record.getField(FIELD1));


        // Wait for messages to be processed
        Assert.assertTrue("Processing events took too long", lilyProxy.getHBaseProxy().waitOnSepIdle(60000L));
        lilyProxy.getSolrProxy().commit();

View Full Code Here

        QName versionedOnlyQN = new QName(namespace, "VersionedOnly");
        RecordType versionedOnlyRT = typeManager.newRecordType(versionedOnlyQN);
        versionedOnlyRT.addFieldTypeEntry(typeManager.newFieldTypeEntry(fieldType2.getId(), false));
        versionedOnlyRT = typeManager.createRecordType(versionedOnlyRT);


        Record record = repository.newRecord();
        record.setRecordType(versionedOnlyQN);
        record.setField(fieldType2.getName(), 111);
        record = repository.create(record);
        RecordId id = record.getId();
        repository.delete(id);


        record = repository.newRecord(id);
        record.setRecordType(versionedOnlyQN);
        record.setField(fieldType2.getName(), 222);
        record = repository.create(record);


        assertEquals(versionedOnlyQN, record.getRecordTypeName());


        record = repository.read(id);
        assertEquals(versionedOnlyQN, record.getRecordTypeName());
        assertEquals(versionedOnlyQN, record.getRecordTypeName(Scope.VERSIONED));
    }

View Full Code Here

        rt.addFieldTypeEntry(nvfieldtype.getId(), false);
        rt = typeManager.createRecordType(rt);


        // Create a record with versions
        RecordId recordId = repository.getIdGenerator().newRecordId();
        Record record = repository.newRecord(recordId);
        record.setRecordType(rt.getName());


        record.setField(nvfield, "nv value 1");
        record = repository.createOrUpdate(record);
        record = repository.read(record.getId());


        assertEquals("nv value 1", record.getField(nvfield));
        assertEquals(rtName, record.getRecordTypeName());


        assertEquals(null, record.getVersion());


        // Delete the record
        repository.delete(recordId);


        // Re-create the record,
        record = repository.newRecord(recordId);
        record.setRecordType(rt.getName());
        record.setField(nvfield, "nv value 2");
        record = repository.createOrUpdate(record);


        assertEquals(rtName, record.getRecordTypeName());
        assertEquals(null, record.getVersion());


        record = repository.read(record.getId());
        assertEquals("nv value 2", record.getField(nvfield));
        assertEquals(rtName, record.getRecordTypeName());
    }

View Full Code Here

        record.setResponseStatus(status);
    }


    @Override
    public IdRecord clone() {
        Record recordClone = this.record.clone();
        return new IdRecordImpl(recordClone, new HashMap<SchemaId, QName>(mapping),
                new EnumMap<Scope, SchemaId>(recordTypeIds));
    }

View Full Code Here

        return cloneRecord(new IdentityRecordStack());
    }


    @Override
    public IdRecord cloneRecord(IdentityRecordStack parentRecords) throws RecordException {
        Record recordClone = this.record.cloneRecord(parentRecords);
        return new IdRecordImpl(recordClone, new HashMap<SchemaId, QName>(mapping),
                new EnumMap<Scope, SchemaId>(recordTypeIds));
    }

View Full Code Here

        lilyProxy.getLilyServerProxy().addIndexFromResource(repository.getRepositoryName(), indexName,
                SolrDefinition.DEFAULT_CORE_NAME, "org/lilyproject/lilyservertestfw/test/lilytestutility_indexerconf.xml",
                60000L);


        // Create record
        Record record = repository.newRecord();
        record.setRecordType(RECORDTYPE1);
        record.setField(FIELD1, "name1");
        record = repository.create(record);
        record = repository.read(record.getId());
        Assert.assertEquals("name1", (String) record.getField(FIELD1));


        // Wait for messages to be processed
        Assert.assertTrue("Processing messages took too long", lilyProxy.waitSepEventsProcessed(10000L));


        // Query Solr
        List<RecordId> recordIds = querySolr("name1");


        Assert.assertTrue(recordIds.contains(record.getId()));


        System.out.println("Original record:" + record.getId().toString());
        System.out.println("Queried record:" + recordIds.get(0).toString());


        //
        // Batch index build scenario
        //
        if (System.getProperty("os.name").startsWith("Windows")) {
            System.out.println("Skipping the Batch index build scenario since this does not work under Windows.");
        } else {
            // Disable incremental index updating
            WriteableIndexerModel indexerModel = lilyProxy.getLilyServerProxy().getIndexerModel();
            String lock = indexerModel.lockIndexer(indexName);
            String subscriptionId;
            try {
                IndexerDefinition index = indexerModel.getIndexer(indexName);
                subscriptionId = index.getSubscriptionId();


                indexerModel.updateIndexer(new IndexerDefinitionBuilder()
                        .startFrom(index)
                        .incrementalIndexingState(IndexerDefinition.IncrementalIndexingState.DO_NOT_SUBSCRIBE)
                        .build(), lock);
            } finally {
                indexerModel.unlockIndexer(lock);
            }


            lilyProxy.getHBaseProxy().waitOnReplicationPeerStopped(subscriptionId);


            // Create record
            record = repository.newRecord();
            record.setRecordType(RECORDTYPE1);
            record.setField(FIELD1, "name2");
            record = repository.create(record);


            // Wait for messages to be processed -- there shouldn't be any
            Assert.assertTrue("Processing messages took too long", lilyProxy.waitSepEventsProcessed(10000L));


            // Record shouldn't be in index yet
            recordIds = querySolr("name2");
            Assert.assertFalse(recordIds.contains(record.getId()));


            // Trigger batch build
            lilyProxy.getLilyServerProxy().batchBuildIndex(indexName, 60000L * 4);


            // Now record should be in index
            recordIds = querySolr("name2");
            Assert.assertTrue(recordIds.contains(record.getId()));
        }
    }

View Full Code Here

        // Basic create-update-delete
        //
        {
            // Create a record
            log.debug("Begin test NV1");
            Record record = defaultTable.newRecord();
            record.setRecordType(nvRecordType1.getName());
            record.setField(nvfield1.getName(), "nvapple");
            record.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record.getId(), nvfield1.getId(), nvTag.getId());
            record = defaultTable.create(record);


            commitIndex();
            verifyResultCount("lily.id:" + record.getId().toString(), 1);
            verifyResultCount("nv_field1:nvapple", 1);


            // Update the record
            log.debug("Begin test NV2");
            record.setField(nvfield1.getName(), "nvpear");
            expectEvent(UPDATE, Table.RECORD.name, record.getId(), nvfield1.getId());
            defaultTable.update(record);


            System.out.println("Updated " + record.getId());
            commitIndex();
            verifyResultCount("nv_field1:nvpear", 1);
            verifyResultCount("nv_field1:nvapple", 0);


            // Do as if field2 changed, while field2 is not present in the document.
            // Such situations can occur if the record is modified before earlier events are processed.
            log.debug("Begin test NV3");
            // TODO send event directly to the Indexer
            // sendEvent(EVENT_RECORD_UPDATED, record.getId(), nvfield2.getId());


            verifyResultCount("nv_field1:nvpear", 1);
            verifyResultCount("nv_field1:nvapple", 0);


            // Add a vtag field pointing to a version. For versionless records, this should have no effect
            log.debug("Begin test NV4");
            record.setField(liveTag.getName(), new Long(1));
            expectEvent(UPDATE, Table.RECORD.name, record.getId(), liveTag.getId());
            defaultTable.update(record);


            commitIndex();
            verifyResultCount("nv_field1:nvpear", 1);
            verifyResultCount("nv_field1:nvapple", 0);


            // Delete the record
            log.debug("Begin test NV5");
            expectEvent(DELETE, Table.RECORD.name, record.getId());
            defaultTable.delete(record.getId());


            commitIndex();


            verifyResultCount("nv_field1:nvpear", 0);
        }


        //
        // Deref
        //
        {
            log.debug("Begin test NV6");
            Record record1 = defaultTable.newRecord();
            record1.setRecordType(nvRecordType1.getName());
            record1.setField(nvfield1.getName(), "nvpear");
            record1.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record1.getId(), nvfield1.getId(), nvTag.getId());
            record1 = defaultTable.create(record1);


            Record record2 = defaultTable.newRecord();
            record2.setRecordType(nvRecordType1.getName());
            record2.setField(nvLinkField1.getName(), new Link(record1.getId()));
            record2.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record2.getId(), nvLinkField1.getId(), nvTag.getId());
            record2 = defaultTable.create(record2);


            commitIndex();
            verifyResultCount("nv_deref1:nvpear", 1);
        }




        //
        // Variant deref
        //
        {
            log.debug("Begin test NV7");
            Record masterRecord = defaultTable.newRecord();
            masterRecord.setRecordType(nvRecordType1.getName());
            masterRecord.setField(nvfield1.getName(), "yellow");
            masterRecord.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, masterRecord.getId(), nvfield1.getId(), nvTag.getId());
            masterRecord = defaultTable.create(masterRecord);


            RecordId var1Id = idGenerator.newRecordId(masterRecord.getId(), Collections.singletonMap("lang", "en"));
            Record var1Record = defaultTable.newRecord(var1Id);
            var1Record.setRecordType(nvRecordType1.getName());
            var1Record.setField(nvfield1.getName(), "green");
            var1Record.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, var1Id, nvfield1.getId(), nvTag.getId());
            defaultTable.create(var1Record);


            Map<String, String> varProps = new HashMap<String, String>();
            varProps.put("lang", "en");
            varProps.put("branch", "dev");
            RecordId var2Id = idGenerator.newRecordId(masterRecord.getId(), varProps);
            Record var2Record = defaultTable.newRecord(var2Id);
            var2Record.setRecordType(nvRecordType1.getName());
            var2Record.setField(nvfield1.getName(), "blue");
            var2Record.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, var2Id, nvfield1.getId(), nvTag.getId());
            defaultTable.create(var2Record);


            commitIndex();
            verifyResultCount("nv_deref2:yellow", 1);
            verifyResultCount("nv_deref3:yellow", 2);
            verifyResultCount("nv_deref4:green", 1);
            verifyResultCount("nv_deref3:green", 0);
            verifyResultCount("nv_deref5:blue", 1);
            verifyResultCount("nv_deref5:green", 0);
            verifyResultCount("nv_deref5:yellow", 0);
            verifyResultCount("nv_deref6:blue", 2);
            verifyResultCount("nv_deref7:blue", 1);
            verifyResultCount("nv_deref8:blue", 0);
        }


        //
        // Update denormalized data
        //
        {
            log.debug("Begin test NV8");
            Record record1 = defaultTable.newRecord(idGenerator.newRecordId("boe"));
            record1.setRecordType(nvRecordType1.getName());
            record1.setField(nvfield1.getName(), "cucumber");
            record1.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record1.getId(), nvfield1.getId(), nvTag.getId());
            record1 = defaultTable.create(record1);


            // Create a record which will contain denormalized data through linking
            Record record2 = defaultTable.newRecord();
            record2.setRecordType(nvRecordType1.getName());
            record2.setField(nvLinkField1.getName(), new Link(record1.getId()));
            record2.setField(nvfield1.getName(), "mushroom");
            record2.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record2.getId(), nvLinkField1.getId(), nvfield1.getId(), nvTag.getId());
            record2 = defaultTable.create(record2);


            // Create a record which will contain denormalized data through master-dereferencing and forward-variant-dereferencing
            RecordId record3Id = idGenerator.newRecordId(record1.getId(), Collections.singletonMap("lang", "en"));
            Record record3 = defaultTable.newRecord(record3Id);
            record3.setRecordType(nvRecordType1.getName());
            record3.setField(nvfield1.getName(), "eggplant");
            record3.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record3.getId(), nvfield1.getId(), nvTag.getId());
            record3 = defaultTable.create(record3);


            // Create a record which will contain denormalized data through variant-dereferencing
            Map<String, String> varprops = new HashMap<String, String>();
            varprops.put("lang", "en");
            varprops.put("branch", "dev");
            RecordId record4Id = idGenerator.newRecordId(record1.getId(), varprops);
            Record record4 = defaultTable.newRecord(record4Id);
            record4.setRecordType(nvRecordType1.getName());
            record4.setField(nvfield1.getName(), "broccoli");
            record4.setField(nvTag.getName(), 0L);
            expectEvent(CREATE, Table.RECORD.name, record4.getId(), nvfield1.getId(), nvTag.getId());
            record4 = defaultTable.create(record4);


            commitIndex();
            verifyResultCount("nv_deref1:cucumber", 1); // record2[nv:linkField1] = record1
            verifyResultCount("nv_deref2:cucumber", 1); // record4{-branch,-lang} = record1
            verifyResultCount("nv_deref3:cucumber", 2); // record3{master} and record4{master} = record1
            verifyResultCount("nv_deref4:eggplant", 1); // record4{-branch} = record3
            verifyResultCount("nv_deref5:broccoli", 1); // record3{+branch} = record4
            verifyResultCount("nv_deref6:broccoli", 2); // record1{+branch,+lang} = record4 (2 tags!)
            verifyResultCount("nv_deref7:broccoli", 1); // record3{+branch=dev} = record4


            // Update record1, check if the others are updated in the index
            log.debug("Begin test NV9");
            record1.setField(nvfield1.getName(), "tomato");
            expectEvent(UPDATE, Table.RECORD.name, record1.getId(), nvfield1.getId());
            record1 = defaultTable.update(record1);


            commitIndex();
            verifyResultCount("nv_deref1:tomato", 1); // record2[ns:nvLinkField1] = record1
            verifyResultCount("nv_deref2:tomato", 1); // record4{-branch,-lang} = record1
            verifyResultCount("nv_deref3:tomato", 2); // record3{master} and record4{master} = record1
            verifyResultCount("nv_deref1:cucumber", 0); // old value should be removed from index (non versioned field!)
            verifyResultCount("nv_deref2:cucumber", 0); // old value should be removed from index (non versioned field!)
            verifyResultCount("nv_deref3:cucumber", 0); // old value should be removed from index (non versioned field!)
            verifyResultCount("nv_deref4:eggplant", 1); // record4(-branch) = record3


            // Update record3, index for record4 should be updated
            log.debug("Begin test NV10");
            record3.setField(nvfield1.getName(), "courgette");
            expectEvent(UPDATE, Table.RECORD.name, record3.getId(), nvfield1.getId());
            defaultTable.update(record3);


            commitIndex();
            verifyResultCount("nv_deref4:courgette", 1); // record4(-branch) = record3
            verifyResultCount("nv_deref4:eggplant", 0); // old value should be removed from index (non versioned field!)


            // Update record4, index for record3 and record1 should be updated
            log.debug("Begin test NV10.1");
            record4.setField(nvfield1.getName(), "cauliflower"); //FIXME: 2nd courgette; use something else here
            expectEvent(UPDATE, Table.RECORD.name, record4.getId(), nvfield1.getId());
            defaultTable.update(record4);


            commitIndex();
            verifyResultCount("nv_deref5:cauliflower", 1); // record3{+branch} produces record4
            verifyResultCount("nv_deref5:broccoli", 0);    // old value should be removed from index
            verifyResultCount("nv_deref5:courgette", 0);   // sanity check, nothing could match
            verifyResultCount("nv_deref6:cauliflower", 2); // record1{+branch,+lang} = record4 (2 vtags!)
            verifyResultCount("nv_deref6:broccoli", 0);    // old value should be removed from index
            verifyResultCount("nv_deref7:cauliflower", 1); // record3{+branch=dev} = record4
            verifyResultCount("nv_deref7:broccoli", 0);    // old value should be removed from index


            // Delete record 3: index for record 4 should be updated
            log.debug("Begin test NV11");
            verifyResultCount("lily.id:" + ClientUtils.escapeQueryChars(record3.getId().toString()), 1);
            expectEvent(DELETE, Table.RECORD.name, record3.getId());
            defaultTable.delete(record3.getId());


            commitIndex();
            verifyResultCount("nv_deref4:cauliflower", 0);
            verifyResultCount("nv_deref3:tomato", 1);
            verifyResultCount("lily.id:" + ClientUtils.escapeQueryChars(record3.getId().toString()), 0);


            // Delete record 4
            log.debug("Begin test NV12");
            expectEvent(DELETE, Table.RECORD.name, record4.getId());
            defaultTable.delete(record4.getId());


            commitIndex();
            verifyResultCount("nv_deref3:tomato", 0);
            verifyResultCount("nv_field1:broccoli", 0);
            verifyResultCount("lily.id:" + ClientUtils.escapeQueryChars(record4.getId().toString()), 0);


            // Delete record 1: index of record 2 should be updated
            log.debug("Begin test NV13");
            expectEvent(DELETE, Table.RECORD.name, record1.getId());
            defaultTable.delete(record1.getId());

View Full Code Here

    private Record generateRecord(TestAction testAction, ValueType valueType) throws RecordException {
        String valueTypeName = valueType.getName();
        String recordTypeName = valueTypeName.substring(valueTypeName.indexOf("<") + 1, valueTypeName.length()-1);
        TestActionContext context = testAction.getContext();
        TestRecordType testRecordType = context.recordTypes.get(QName.fromString(recordTypeName));
        Record record = context.repository.getRecordFactory().newRecord();
        record.setRecordType(testRecordType.getRecordType().getName());
        List<TestFieldType> testFieldTypes = testRecordType.getFieldTypes();
        for (TestFieldType testFieldType : testFieldTypes) {
            ActionResult actionResult = testFieldType.generateValue(testAction);
            record.setField(testFieldType.getFieldType().getName(), actionResult.object);


        }
        return record;
    }

View Full Code Here

                Collections.<String>emptyList()
        );


        LilyIndexerConf idxConf = LilyIndexerConfBuilder.build(new ByteArrayInputStream(conf.getBytes()), repository);


        Record recordTypeA = newRecordOfType(new QName("ns1", "typeA"));
        Record recordTypeB = newRecordOfType(new QName("ns1", "typeB"));


        assertEquals(ImmutableSet.of(vtag1.getId()),
                idxConf.getRecordFilter().getIndexCase(Table.RECORD.name, recordTypeA).getVersionTags());
        assertEquals(ImmutableSet.of(vtag2.getId()),
                idxConf.getRecordFilter().getIndexCase(Table.RECORD.name, recordTypeB).getVersionTags());

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.lilyproject.repository.api.Record

$.MyMapper

org.lilyproject.avro.AvroConverterTest

org.lilyproject.avro.AvroLilyImpl

org.lilyproject.avro.AvroLilyImplTest

org.lilyproject.avro.repository.RecordAsBytesConverter

org.lilyproject.indexer.batchbuild.test.BatchBuildTest

org.lilyproject.indexer.engine.test.IndexerTest

org.lilyproject.indexer.engine.test.RecordMatcherTest

org.lilyproject.indexer.engine.ValueEvaluator

org.lilyproject.indexer.hbase.mapper.LilyResultToSolrMapper

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.