Examples of org.lilyproject.repository.api.RecordType

org.lilyproject.repository.api.RecordType
A record type describes the schema to be followed by a {@link Record}.
Record types are managed via the {@link TypeManager}. To instantiate a RecordType use {@link TypeManager#newRecordType(QName)} TypeManager.newRecordType}. As all entities within this API,record types are dumb data objects.
A record type consists of:
- a list of field types, associated via {@link FieldTypeEntry} which defines properties specific to the useof a field type within this record type.
- a list of supertypes, these are references to other record types that are parent types for this record type.
Record types are versioned: upon each update, a new version of the record type is created. Record store a pointer to the particular version of a record type that was used when creating/updating a record type. The references to the supertype record types are also to specific versions.
A record type has two unique identifiers:
- a system-generated id, immutable after creation of the record type
- a name in the form of a {@link QName qualified (namespaced) name}, which is mutable after creation of the record type. Changing the name of a record type affects all versions of the record type (the name is a non-versioned property of the record type).

        }
        QName rtName = new QName("builderNS", "builderName");
        builder.name(rtName);
        builder.field(fieldType1.getId(), false);
        builder.field(fieldType2.getId(), true);
        RecordType recordType = builder.create();


        RecordType readRecordType = typeManager.getRecordTypeByName(rtName, null);
        assertEquals(recordType, readRecordType);
        assertFalse(readRecordType.getFieldTypeEntry(fieldType1.getId()).isMandatory());
        assertTrue(readRecordType.getFieldTypeEntry(fieldType2.getId()).isMandatory());


        builder.reset();
        builder.id(recordType.getId());
        recordType = builder.update();
        readRecordType = typeManager.getRecordTypeByName(rtName, null);
        assertEquals(recordType, readRecordType);
        assertEquals(Long.valueOf(2), readRecordType.getVersion());
        assertNull(readRecordType.getFieldTypeEntry(fieldType1.getId()));
    }

View Full Code Here

        FieldType field26 = typeManager.createFieldType("STRING", new QName(NS, "field26"), VERSIONED);
        FieldType field27 = typeManager.createFieldType("STRING", new QName(NS, "field27"), VERSIONED);
        FieldType field28 = typeManager.createFieldType("STRING", new QName(NS, "field28"), VERSIONED);
        FieldType field29 = typeManager.createFieldType("STRING", new QName(NS, "field29"), VERSIONED);


        RecordType supertype1 = typeManager.recordTypeBuilder().name(NS, "supertype1").fieldEntry().use(field21).add().create();
        RecordType supertype2 = typeManager.recordTypeBuilder().name(NS, "supertype2").fieldEntry().use(field22).add().create();
        RecordType supertype3 = typeManager.recordTypeBuilder().name(NS, "supertype3").fieldEntry().use(field23).add().create();
        RecordType supertype4 = typeManager.recordTypeBuilder().name(NS, "supertype4").fieldEntry().use(field24).add().create();
        RecordType supertype5 = typeManager.recordTypeBuilder().name(NS, "supertype5").fieldEntry().use(field25).add().create();
        RecordType supertype6 = typeManager.recordTypeBuilder().name(NS, "supertype6").fieldEntry().use(field26).add().create();
        RecordType supertype7 = typeManager.recordTypeBuilder().name(NS, "supertype7").fieldEntry().use(field27).add().create();
        // give supertype7 two more versions
        supertype7.addFieldTypeEntry(field28.getId(), false);
        supertype7 = typeManager.updateRecordType(supertype7);
        supertype7.addFieldTypeEntry(field29.getId(), false);
        supertype7 = typeManager.updateRecordType(supertype7);


        RecordType recordType = typeManager
                .recordTypeBuilder()
                .defaultNamespace(NS)
                .name("recordType1")


                /* Adding previously defined fields */
                /* By ID */
                .fieldEntry().id(field1.getId()).add()
                /* By object + test mandatory flag */
                .fieldEntry().use(field2).mandatory().add()
                /* By non-qualified name */
                .fieldEntry().name("field3").add()
                /* By qualified name */
                .fieldEntry().name(new QName(NS, "field4")).add()
                /* By indirect qualified name*/
                .fieldEntry().name(NS, "field5").add()


                /* Adding newly created fields */
                /* Using default default scope */
                .fieldEntry().defineField().name("field10").type("LIST<STRING>").create().add()
                /* Using default type (STRING) */
                .fieldEntry().defineField().name("field11").create().add()
                /* Using QName */
                .fieldEntry().defineField().name(new QName(NS, "field12")).create().add()
                /* Using explicit scope */
                .fieldEntry().defineField().name("field13").type("LONG").scope(VERSIONED).create().add()
                /* Using different default scope */
                .defaultScope(Scope.VERSIONED)
                .fieldEntry().defineField().name("field14").create().add()
                /* Using indirect qualified name*/
                .fieldEntry().defineField().name(NS, "field15").create().add()


                /* Adding supertypes */
                .supertype().id(supertype1.getId()).add()
                .supertype().name("supertype2").add()
                .supertype().name(new QName(NS, "supertype3")).add()
                .supertype().name(NS, "supertype4").add()
                .supertype().use(supertype5).add()
                .supertype().name(NS, "supertype7").version(2L).add()


                .create();


        //
        // Global checks
        //
        assertEquals(new QName(NS, "recordType1"), recordType.getName());


        //
        // Verify fields
        //
        assertEquals(11, recordType.getFieldTypeEntries().size());


        assertFalse(recordType.getFieldTypeEntry(field1.getId()).isMandatory());
        assertTrue(recordType.getFieldTypeEntry(field2.getId()).isMandatory());
        assertFalse(recordType.getFieldTypeEntry(field3.getId()).isMandatory());


        // Verify the inline created fields
        FieldType field10 = typeManager.getFieldTypeByName(new QName(NS, "field10"));
        assertEquals("LIST<STRING>", field10.getValueType().getName());
        assertEquals(Scope.NON_VERSIONED, field10.getScope());
        assertNotNull(recordType.getFieldTypeEntry(field10.getId()));


        FieldType field11 = typeManager.getFieldTypeByName(new QName(NS, "field11"));
        assertEquals("STRING", field11.getValueType().getName());
        assertEquals(Scope.NON_VERSIONED, field11.getScope());
        assertNotNull(recordType.getFieldTypeEntry(field11.getId()));


        FieldType field13 = typeManager.getFieldTypeByName(new QName(NS, "field13"));
        assertEquals(Scope.VERSIONED, field13.getScope());


        FieldType field14 = typeManager.getFieldTypeByName(new QName(NS, "field14"));
        assertEquals(Scope.VERSIONED, field14.getScope());


        //
        // Verify supertypes
        //
        Map<SchemaId, Long> supertypes = recordType.getSupertypes();
        assertEquals(6, supertypes.size());
        assertTrue(supertypes.containsKey(supertype1.getId()));
        assertTrue(supertypes.containsKey(supertype2.getId()));
        assertTrue(supertypes.containsKey(supertype3.getId()));
        assertTrue(supertypes.containsKey(supertype4.getId()));

View Full Code Here


    @Test
    public void testRecordTypeBuilderCreateOrUpdate() throws Exception {
        String NS = "testRecordTypeBuilderCreateOrUpdate";


        RecordType recordType = null;
        for (int i = 0; i < 3; i++) {
            recordType = typeManager
                    .recordTypeBuilder()
                    .defaultNamespace(NS)
                    .name("recordType1")
                    .fieldEntry().defineField().name("field1").createOrUpdate().add()
                    .fieldEntry().defineField().name("field2").createOrUpdate().add()
                    .createOrUpdate();
        }


        assertEquals(new Long(1L), recordType.getVersion());


        recordType = typeManager
                .recordTypeBuilder()
                .defaultNamespace(NS)
                .name("recordType1")
                .fieldEntry().defineField().name("field1").createOrUpdate().add()
                .fieldEntry().defineField().name("field2").createOrUpdate().add()
                .fieldEntry().defineField().name("field3").createOrUpdate().add()
                .createOrUpdate();


        assertEquals(new Long(2L), recordType.getVersion());
    }

View Full Code Here

        //     rtB rtD
        //      | /
        //     rtC
        //


        RecordType rtA = typeManager.recordTypeBuilder()
                .name("RefreshSubtypes", "rtA")
                .fieldEntry().use(fieldType1).add()
                .create();


        RecordType rtB = typeManager.recordTypeBuilder()
                .name("RefreshSubtypes", "rtB")
                .fieldEntry().use(fieldType1).add()
                .supertype().use(rtA).add()
                .create();


        RecordType rtD = typeManager.recordTypeBuilder()
                .name("RefreshSubtypes", "rtD")
                .fieldEntry().use(fieldType1).add()
                .supertype().use(rtA).add()
                .create();


        RecordType rtC = typeManager.recordTypeBuilder()
                .name("RefreshSubtypes", "rtC")
                .fieldEntry().use(fieldType1).add()
                .supertype().use(rtB).add()
                .supertype().use(rtD).add()
                .create();


        // Check currently the all point to the first version of their supertype
        assertEquals(Long.valueOf(1L), rtD.getSupertypes().get(rtA.getId()));
        assertEquals(Long.valueOf(1L), rtB.getSupertypes().get(rtA.getId()));
        assertEquals(Long.valueOf(1L), rtC.getSupertypes().get(rtB.getId()));
        assertEquals(Long.valueOf(1L), rtC.getSupertypes().get(rtD.getId()));


        // Update record type B, pointer in record type C should be updated
        rtB.addFieldTypeEntry(fieldType2.getId(), false);
        rtB = typeManager.updateRecordType(rtB, true);


        // Now C should point to new version of B
        waitOnRecordTypeVersion(2L, rtC.getId());
        rtC = typeManager.getRecordTypeById(rtC.getId(), null);
        assertEquals(Long.valueOf(2L), rtC.getSupertypes().get(rtB.getId()));
        // And thus C itself should have two versions
        assertEquals(Long.valueOf(2L), rtC.getVersion());


        // Update record type A, this should cause updates to B, C and D
        rtA.addFieldTypeEntry(fieldType2.getId(), false);
        rtA = typeManager.updateRecordType(rtA, true);


        // Check the subtypes were updated
        waitOnRecordTypeVersion(3L, rtB.getId());
        rtB = typeManager.getRecordTypeById(rtB.getId(), null);
        assertEquals(Long.valueOf(3L), rtB.getVersion());
        assertEquals(Long.valueOf(2L), rtB.getSupertypes().get(rtA.getId()));


        waitOnRecordTypeVersion(2L, rtD.getId());
        rtD = typeManager.getRecordTypeById(rtD.getId(), null);
        assertEquals(Long.valueOf(2L), rtD.getVersion());
        assertEquals(Long.valueOf(2L), rtD.getSupertypes().get(rtA.getId()));


        waitOnRecordTypeVersion(4L, rtC.getId());
        rtC = typeManager.getRecordTypeById(rtC.getId(), null);
        assertEquals(Long.valueOf(4L), rtC.getVersion());
        assertEquals(Long.valueOf(3L), rtC.getSupertypes().get(rtB.getId()));
        assertEquals(Long.valueOf(2L), rtC.getSupertypes().get(rtD.getId()));
    }

View Full Code Here

        assertEquals(Long.valueOf(2L), rtC.getSupertypes().get(rtD.getId()));
    }
    
    @Test
    public void testGetFieldTypesForRecordType_WithRecursion() throws TypeException, RepositoryException, InterruptedException {
        RecordType rtA = typeManager.recordTypeBuilder()
                .name("GetFieldTypes", "rtA")
                .fieldEntry().use(fieldType1).add()
                .create();


        RecordType rtB = typeManager.recordTypeBuilder()
                .name("GetFieldTypes", "rtB")
                .fieldEntry().use(fieldType2).add()
                .supertype().use(rtA).add()
                .create();
        
        RecordType rtC = typeManager.recordTypeBuilder()
                .name("GetFieldTypes", "rtC")
                .fieldEntry().use(fieldType3).add()
                .supertype().use(rtB).add()
                .create();

View Full Code Here

        TypeManager typeManager = repository.getTypeManager();
        ValueType blobType = typeManager.getValueType("BLOB");
        FieldType blobFieldType = typeManager.newFieldType(blobType, new QName(NS, "data"), Scope.VERSIONED);
        blobFieldType = typeManager.createFieldType(blobFieldType);


        RecordType recordType = typeManager.newRecordType(new QName(NS, "file"));
        recordType.addFieldTypeEntry(blobFieldType.getId(), true);
        recordType = typeManager.createRecordType(recordType);




        // Upload a blob that, based upon the current default config, should end up in HBase
        //  (> 5000 bytes and < 200000 bytes)

View Full Code Here

        // Create a field type and record type
        TypeManager typeManager = repository.getTypeManager();
        FieldType fieldType = typeManager.newFieldType("STRING", new QName(NS, "scanfield"), Scope.VERSIONED);
        fieldType = typeManager.createFieldType(fieldType);


        RecordType recordType = typeManager.newRecordType(new QName(NS, "scanrt"));
        recordType.addFieldTypeEntry(fieldType.getId(), true);
        recordType = typeManager.createRecordType(recordType);


        // Create some records
        for (int i = 0; i < 10; i++) {
            Record record = repository.newRecord();

View Full Code Here

    }


    public RecordType convert(AvroRecordType avroRecordType, TypeManager typeManager) throws RepositoryException {
        SchemaId recordTypeId = convert(avroRecordType.getId());
        QName recordTypeName = convert(avroRecordType.getName());
        RecordType recordType = typeManager.newRecordType(recordTypeId, recordTypeName);
        recordType.setVersion(avroRecordType.getVersion());
        List<AvroFieldTypeEntry> fieldTypeEntries = avroRecordType.getFieldTypeEntries();
        if (fieldTypeEntries != null) {
            for (AvroFieldTypeEntry avroFieldTypeEntry : fieldTypeEntries) {
                recordType.addFieldTypeEntry(convert(avroFieldTypeEntry, typeManager));
            }
        }
        List<AvroSupertype> supertypes = avroRecordType.getSupertypes();
        if (supertypes != null) {
            for (AvroSupertype avroSupertype : supertypes) {
                recordType.addSupertype(convert(avroSupertype.getRecordTypeId()), avroSupertype.getRecordTypeVersion());
            }
        }
        return recordType;
    }

View Full Code Here

        IdGenerator idGenerator = repository.getIdGenerator();
        LTable table = repository.getDefaultTable();


        FieldType ft1 = typeManager.createFieldType("STRING", new QName("test", "field1"), Scope.NON_VERSIONED);


        RecordType rt1 = typeManager.recordTypeBuilder()
                .defaultNamespace("test")
                .name("rt1")
                .fieldEntry().use(ft1).add()
                .create();


        for (int i = 0; i < 100; i++) {
            table.recordBuilder()
                    .id(String.format("%1$03d", i))
                    .recordType(rt1.getName())
                    .field(ft1.getName(), "foo bar bar")
                    .create();
        }


        //
        // Also create some content in another repository with two tables
        //
        RepositoryModelImpl repositoryModel = new RepositoryModelImpl(lilyProxy.getLilyServerProxy().getZooKeeper());
        String repositoryName = "otherrepo";
        repositoryModel.create(repositoryName);
        assertTrue(repositoryModel.waitUntilRepositoryInState(repositoryName, RepositoryLifecycleState.ACTIVE, 60000L));
        repositoryModel.close();


        LRepository repository2 = repoMgr.getRepository(repositoryName);
        repository2.getTableManager().createTable("foobar");
        LTable table2 = repository2.getTable("foobar");
        LTable table3 = repository2.getDefaultTable();


        for (int i = 0; i < 50; i++) {
            table2.recordBuilder()
                    .id(String.valueOf(i))
                    .recordType(rt1.getName())
                    .field(ft1.getName(), "foo bar bar")
                    .create();
        }


        for (int i = 0; i < 20; i++) {
            table3.recordBuilder()
                    .id(String.valueOf(i))
                    .recordType(rt1.getName())
                    .field(ft1.getName(), "foo bar bar")
                    .create();
        }


        //

View Full Code Here

            map.put(typeManager.getFieldTypeByName(qname).getId(), qname);            
        }


        Map<Scope,SchemaId> recordTypeIds = Maps.newHashMap();
        for (Scope scope : Scope.values()) {
            RecordType recordType = typeManager.getRecordTypeByName(record.getRecordTypeName(scope), record.getVersion());
            if (recordType != null) {
                recordTypeIds.put(scope, recordType.getId());
            }
        }
        IdRecord idRecord = new IdRecordImpl(record, map, recordTypeIds);
        return idRecord;
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

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

org.lilyproject.avro.AvroConverter

org.lilyproject.avro.AvroConverterTest

org.lilyproject.indexer.engine.test.IndexerTest

org.lilyproject.indexer.engine.test.RecordMatcherTest

org.lilyproject.lilyservertestfw.test.KeepDataTest

org.lilyproject.lilyservertestfw.test.LilyProxyTest

org.lilyproject.linkindex.test.LinkIndexTest

org.lilyproject.mapreduce.test.MapReduceTest

org.lilyproject.process.test.DecoratorTest

org.lilyproject.process.test.LilyClientTest

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.