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).

                    .scope(Scope.VERSIONED)
                    .type("STRING").create();
        }
        for (QName name : new QName[]{new QName(NS, "Alpha"), new QName(NS, "Beta"), new QName(NS2, "Alpha"),
                new QName(NS2, "Beta")}) {
            RecordType recordType = typeManager.newRecordType(name);
            addNvFieldTypes(recordType);
            addVFieldTypes(recordType);
            for (int i = 1; i <= 6; i++) {
                recordType
                        .addFieldTypeEntry(typeManager.getFieldTypeByName(new QName(NS, "nvmatch" + i)).getId(), false);
                recordType
                        .addFieldTypeEntry(typeManager.getFieldTypeByName(new QName(NS2, "match" + i)).getId(), false);
            }
            // Link fields
            for (int i = 1; i <= 2; i++) {
                recordType.addFieldTypeEntry(typeManager.getFieldTypeByName(new QName(NS, "nv_linkfield" + i)).getId(),
                        false);
                recordType.addFieldTypeEntry(typeManager.getFieldTypeByName(new QName(NS2, "v_linkfield" + i)).getId(),
                        false);
            }
            typeManager.createRecordType(recordType);
        }

View Full Code Here


        FieldType field13 = typeManager.createFieldType(blobValueType, new QName(DYN_NS2, "field13"), Scope.VERSIONED);


        FieldType field14 = typeManager.createFieldType(blobValueType, new QName(DYN_NS2, "field14"), Scope.VERSIONED);


        RecordType rt = typeManager.newRecordType(new QName(DYN_NS1, "RecordType"));
        // It's not necessary to add the fields
        rt = typeManager.createRecordType(rt);


        changeIndexUpdater("indexerconf_dynfields.xml");


        //
        // Test various matching options
        //
        {
            log.debug("Begin test V300");
            // Create a record
            Record record = defaultTable.newRecord();
            record.setRecordType(rt.getName());


            // namespace match fields
            record.setField(field1.getName(), "vector");
            record.setField(field2.getName(), "circle");
            // name match fields
            record.setField(field3.getName(), "sphere");
            record.setField(field4.getName(), new Long(983));
            record.setField(field5.getName(), Arrays.asList("prism", "cone"));
            // scope match fields
            record.setField(field6.getName(), "polygon");
            record.setField(field7.getName(), "polyhedron");
            // type match fields
            record.setField(field8.getName(), new LocalDate(2011, 4, 11));
            // multi-value match fields
            record.setField(field9.getName(), Arrays.asList("decagon", "dodecahedron"));
            // hierarchical match fields
            record.setField(field10.getName(), new HierarchyPath("triangle", "knot"));


            expectEvent(CREATE, Table.RECORD.name, record.getId(), 1L, null, field1.getId(), field2.getId(), field3.getId(),
                    field4.getId(), field5.getId(), field6.getId(), field7.getId(), field8.getId(), field9.getId(),
                    field10.getId());
            record = defaultTable.create(record);


            commitIndex();


            // Verify only the field from the matched namespace was indexed
            verifyResultCount("dyn1_field1_string:vector", 1);
            verifyResultCount("dyn1_field2_string:circle", 0);


            // Verify name-based match
            verifyResultCount("nameMatch_field3_string:sphere", 1);
            verifyResultCount("nameMatch_field4_long:983", 1);
            verifyResultCount("nameMatch_field5_string_mv:prism", 1);
            verifyResultCount("nameMatch_field5_string_mv:cone", 1);


            // Verify scope-based match
            verifyResultCount("scopeMatch_field6_string:polygon", 0);
            verifyResultCount("scopeMatch_field7_string:polyhedron", 1);


            // Verify type-based match
            verifyResultCount("typeMatch_field8_date:\"2011-04-11T00:00:00Z/DAY\"", 1);


            // Verify multi-value based match
            verifyResultCount("multiValueMatch_field9_string_mv:decagon", 1);


            // Verify hierarchical based match
            verifyResultCount("hierarchicalMatch_field10_hier_literal:\"/triangle/knot\"", 1);
        }


        //
        // Test that index is updated when fields change, without any change to vtags. This verifies
        // that the logic which verifies whether any reindexing needs to be done takes dynamic fields
        // into account.
        //
        {
            log.debug("Begin test V301");
            Record record = defaultTable.newRecord();
            record.setRecordType(rt.getName());


            record.setField(field11.getName(), "parallelepiped");
            record.setField(field12.getName(), "rectangle");


            expectEvent(CREATE, Table.RECORD.name, record.getId(), 1L, null, field11.getId(), field12.getId());
            record = defaultTable.create(record);


            commitIndex();


            verifyResultCount("field11_string:parallelepiped", 1);
            verifyResultCount("field12_string:rectangle", 1);


            // Update only the dynamically indexed field
            record.setField(field12.getName(), "square");
            expectEvent(UPDATE, Table.RECORD.name, record.getId(), null, 1L, field12.getId());
            record = defaultTable.update(record, true, true);
            commitIndex();
            verifyResultCount("field12_string:square", 1);


            // Update only the statically indexed field
            record.setField(field11.getName(), "square");
            expectEvent(UPDATE, Table.RECORD.name, record.getId(), null, 1L, field11.getId());
            record = defaultTable.update(record, true, true);
            commitIndex();
            verifyResultCount("field11_string:square", 1);
        }


        //
        // Test blobs
        //
        {
            log.debug("Begin test V302");


            Record record = defaultTable.newRecord();
            record.setRecordType(rt.getName());


            Blob blob1 = createBlob("blob2.pdf", "application/pdf", "blob2.pdf");
            Blob blob2 = createBlob("blob2.pdf", "application/pdf", "blob2.pdf");


            record.setField(field13.getName(), blob1);
            record.setField(field14.getName(), blob2);


            expectEvent(CREATE, Table.RECORD.name, record.getId(), 1L, null, field13.getId(), field14.getId());
            record = defaultTable.create(record);


            commitIndex();


            // extractContent is not enabled for field13, search on content should not find anything
            verifyResultCount("field13_string:tired", 0);


            // extractContent is enabled for field14
            verifyResultCount("field14_string:tired", 1);
        }


        //
        // Attention: we change the indexerconf here
        //
        changeIndexUpdater("indexerconf_dynfields_continue.xml");


        //
        // Test the fall-through behavior (continue="true") of dynamic fields
        //
        {
            log.debug("Begin test V303");


            Record record = defaultTable.newRecord();
            record.setRecordType(rt.getName());


            record.setField(field1.getName(), "mega");
            record.setField(field2.getName(), "giga");


            expectEvent(CREATE, Table.RECORD.name, record.getId(), 1L, null, field1.getId(), field2.getId());
            record = defaultTable.create(record);


            commitIndex();


            verifyResultCount("dyncont_field1_first_string:mega", 1);
            verifyResultCount("dyncont_field2_first_string:giga", 1);


            verifyResultCount("dyncont_field1_second_string:mega", 1);
            verifyResultCount("dyncont_field2_second_string:giga", 1);


            verifyResultCount("dyncont_field1_third_string:mega", 0);
            verifyResultCount("dyncont_field2_third_string:giga", 0);
        }


        //
        // Attention: we change the indexerconf here
        //
        changeIndexUpdater("indexerconf_fulldynamic.xml");


        //
        // Test a 'fully dynamic' mapping
        //
        {
            log.debug("Begin test V304");


            Record record = defaultTable.newRecord();
            record.setRecordType(rt.getName());


            Blob blob = createBlob("blob2.pdf", "application/pdf", "blob2.pdf");


            record.setField(field1.getName(), "gauss");
            record.setField(field2.getName(), "hilbert");

View Full Code Here


        FieldType field1 = typeManager.createFieldType(stringValueType, new QName(NS, "sf_field1"), Scope.VERSIONED);


        FieldType field2 = typeManager.createFieldType(linkValueType, new QName(NS, "sf_field2"), Scope.VERSIONED);


        RecordType supertype1 = typeManager.newRecordType(new QName(NS, "sf_supertype1"));
        supertype1 = typeManager.createRecordType(supertype1);


        RecordType supertype2 = typeManager.newRecordType(new QName(NS, "sf_supertype2"));
        supertype2 = typeManager.createRecordType(supertype2);


        // Create a record type with two versions
        RecordType rt = typeManager.newRecordType(new QName(NS, "sf_rt"));
        rt.addFieldTypeEntry(field1.getId(), false);
        rt.addFieldTypeEntry(field2.getId(), false);
        rt.addSupertype(supertype1.getId());
        rt = typeManager.createRecordType(rt);


        rt.addSupertype(supertype2.getId(), supertype2.getVersion());
        rt = typeManager.updateRecordType(rt);


        RecordType rt2 = typeManager.newRecordType(new QName(NS, "sf_rt2"));
        rt2.addFieldTypeEntry(field1.getId(), false);
        rt2.addFieldTypeEntry(field2.getId(), false);
        rt2 = typeManager.createRecordType(rt2);


        //
        // Change indexer conf
        //
        log.debug("Begin test V402");
        changeIndexUpdater("indexerconf_sysfields.xml");


        //
        // Create content
        //


        // Create a record that uses version 1 of the record type
        log.debug("Begin test V403");
        Record record1 = defaultTable.newRecord(idGenerator.newRecordId());
        record1.setRecordType(rt.getName(), 1L);
        record1.setField(field1.getName(), "acute");
        expectEvent(CREATE, Table.RECORD.name, record1.getId(), 1L, null, field1.getId());
        record1 = defaultTable.createOrUpdate(record1);


        // Create a record that uses version 2 of the record type
        log.debug("Begin test V405");
        Record record2 = defaultTable.newRecord(idGenerator.newRecordId());
        record2.setRecordType(rt.getName(), 2L);
        record2.setField(field1.getName(), "obtuse");
        expectEvent(CREATE, Table.RECORD.name, record2.getId(), 1L, null, field1.getId());
        record2 = defaultTable.createOrUpdate(record2);


        // Create a record which links to one of the other records
        log.debug("Begin test V406");
        Record record3 = defaultTable.newRecord(idGenerator.newRecordId());
        record3.setRecordType(rt.getName());
        record3.setField(field2.getName(), new Link(record2.getId()));
        expectEvent(CREATE, Table.RECORD.name, record3.getId(), 1L, null, field2.getId());
        record3 = defaultTable.createOrUpdate(record3);


        //
        // Test searches
        //
        commitIndex();


        log.debug("Begin test V407");


        verifyResultCount("sf_field1_string:acute", 1);
        verifyResultCount("sf_field1_string:obtuse", 1);


        // recordType
        verifyResultCount("+sf_field1_string:acute +recordType_literal:" +
                qesc("{org.lilyproject.indexer.test}sf_rt"), 1);
        verifyResultCount("+sf_field1_string:obtuse +recordType_literal:" +
                qesc("{org.lilyproject.indexer.test}sf_rt"), 1);


        // recordTypeWithVersion
        verifyResultCount("+sf_field1_string:acute +recordTypeWithVersion_literal:" +
                qesc("{org.lilyproject.indexer.test}sf_rt:1"), 1);
        verifyResultCount("+sf_field1_string:acute +recordTypeWithVersion_literal:" +
                qesc("{org.lilyproject.indexer.test}sf_rt:2"), 0);
        verifyResultCount("+sf_field1_string:obtuse +recordTypeWithVersion_literal:" +
                qesc("{org.lilyproject.indexer.test}sf_rt:2"), 1);


        // recordTypeName
        verifyResultCount("+sf_field1_string:acute +recordTypeName_literal:" + qesc("sf_rt"), 1);


        // recordTypeNamespace
        verifyResultCount("+sf_field1_string:acute +recordTypeNamespace_literal:" +
                qesc("org.lilyproject.indexer.test"), 1);


        // recordTypeVersion
        verifyResultCount("+sf_field1_string:acute +recordTypeVersion_literal:1", 1);
        verifyResultCount("+sf_field1_string:obtuse +recordTypeVersion_literal:2", 1);


        // supertypes
        verifyResultCount("+sf_field1_string:acute +supertypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype1"), 1);
        verifyResultCount("+sf_field1_string:acute +supertypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype2"), 0);
        verifyResultCount("+sf_field1_string:acute +supertypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_rt"), 0);


        verifyResultCount("+sf_field1_string:obtuse +supertypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype1"), 1);
        verifyResultCount("+sf_field1_string:obtuse +supertypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype2"), 1);


        // supertypesWithVersion
        verifyResultCount("+sf_field1_string:acute +supertypesWithVersion_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype1:1"), 1);


        // supertypeNames
        verifyResultCount("+sf_field1_string:obtuse +supertypeNames_literal_mv:" + qesc("sf_supertype1"), 1);
        verifyResultCount("+sf_field1_string:obtuse +supertypeNames_literal_mv:" + qesc("sf_supertype2"), 1);
        verifyResultCount("+sf_field1_string:obtuse +supertypeNames_literal_mv:" + qesc("sf_supertype_not_existing"), 0);


        // supertypeNamespaces
        verifyResultCount("+sf_field1_string:obtuse +supertypeNamespaces_literal_mv:" +
                qesc("org.lilyproject.indexer.test"), 1);


        // recordTypes (record type + supertypes)
        verifyResultCount("+sf_field1_string:acute +recordTypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype1"), 1);
        verifyResultCount("+sf_field1_string:acute +recordTypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype2"), 0);
        verifyResultCount("+sf_field1_string:acute +recordTypes_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_rt"), 1);


        // recordTypesWithVersion
        verifyResultCount("+sf_field1_string:obtuse +recordTypesWithVersion_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype1:1"), 1);
        verifyResultCount("+sf_field1_string:obtuse +recordTypesWithVersion_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_supertype2:1"), 1);
        verifyResultCount("+sf_field1_string:obtuse +recordTypesWithVersion_literal_mv:" +
                qesc("{org.lilyproject.indexer.test}sf_rt:2"), 1);


        // recordTypeNames
        verifyResultCount("+sf_field1_string:obtuse +recordTypeNames_literal_mv:" + qesc("sf_supertype1"), 1);
        verifyResultCount("+sf_field1_string:obtuse +recordTypeNames_literal_mv:" + qesc("sf_supertype2"), 1);
        verifyResultCount("+sf_field1_string:obtuse +recordTypeNames_literal_mv:" + qesc("sf_rt"), 1);


        // recordTypeNamespaces
        verifyResultCount("+sf_field1_string:obtuse +recordTypeNamespaces_literal_mv:" +
                qesc("org.lilyproject.indexer.test"), 1);


        // record type via deref
        verifyResultCount("+recordType_deref_literal:" + qesc("{org.lilyproject.indexer.test}sf_rt"), 1);


        // Update record 2, can't verify anything immediately, this is just to check denormalized
        // update of expressions pointing to the fake system fields does not give problems
        log.debug("Begin test V408");
        record2.setField(field1.getName(), "obtuse2");
        expectEvent(UPDATE, Table.RECORD.name, record2.getId(), 2L, null, field1.getId());
        record2 = defaultTable.createOrUpdate(record2);


        // Change record type of record 2. The denormalized reference of it stored in the index entry
        // of record 3 will not be updated as this is currently not supported.
        log.debug("Begin test V409");
        record2 = defaultTable.newRecord(record2.getId());
        record2.setRecordType(rt2.getName());
        record2.setField(field1.getName(),
                "obtuse3"); // currently can't only change record type, so touch field as well
        expectEvent(UPDATE, Table.RECORD.name, record2.getId(), 3L, null, true, field1.getId());
        record2 = defaultTable.update(record2);

View Full Code Here

                new QName(NS, "cf_record"), Scope.NON_VERSIONED);


        FieldType recordListField = typeManager.createFieldType(typeManager.getValueType("LIST<RECORD>"),
                new QName(NS, "cf_recordlist"), Scope.NON_VERSIONED);


        RecordType cfRecordType = typeManager.recordTypeBuilder()
                .name(new QName(NS, "ComplexFieldsRecordType"))
                .field(nestedListsField.getId(), false)
                .field(recordField.getId(), false)
                .field(recordListField.getId(), false)
                .create();


        //
        // Change indexer conf
        //
        log.debug("Begin test V502");
        changeIndexUpdater("indexerconf_complexfields.xml");


        {
            //
            // Test
            //
            RecordId recordId = idGenerator.newRecordId();
            expectEvent(CREATE, Table.RECORD.name, recordId, nestedListsField.getId(), recordField.getId(),
                    recordListField.getId());


            defaultTable
                    .recordBuilder()
                    .id(recordId)
                    .recordType(cfRecordType.getName())
                    .field(nestedListsField.getName(),
                            Arrays.asList(
                                    Arrays.asList("dutch", "french", "english"),
                                    Arrays.asList("italian", "greek")
                            ))
                    .field(recordField.getName(),
                            defaultTable
                                    .recordBuilder()
                                    .recordType(nvRecordType1.getName())
                                    .field(nvfield1.getName(), "german")
                                    .field(nvfield2.getName(), "spanish")
                                    .build())
                    .field(recordListField.getName(),
                            Arrays.asList(
                                    defaultTable
                                            .recordBuilder()
                                            .recordType(nvRecordType1.getName())
                                            .field(nvfield1.getName(), "swedish")
                                            .field(nvfield2.getName(), "chinese")
                                            .build(),
                                    defaultTable
                                            .recordBuilder()
                                            .recordType(nvRecordType1.getName())
                                            .field(nvfield1.getName(), "vietnamese")
                                            .field(nvfield2.getName(), "wolof")
                                            .build()
                            )
                    )
                    .create();


            commitIndex();


            verifyResultCount("+cf_nestedlists:italian", 1);
            verifyResultCount("+cf_record:german", 1);
            verifyResultCount("+cf_recordlist:chinese", 1);


            verifyResultCount("+cf_recordlist_field1:swedish", 1);
            verifyResultCount("+cf_recordlist_field1:vietnamese", 1);
            verifyResultCount("+cf_recordlist_field1:chinese", 0);
            verifyResultCount("+cf_recordlist_field1:wolof", 0);


            verifyResultCount("+cf_record_field1:german", 1);
            verifyResultCount("+cf_record_field1:spanish", 0);
        }


        {
            log.debug("Begin test CF503");


            Record beta = defaultTable.recordBuilder()
                    .recordType(vRecordType1.getName())
                    .field(vfield1.getName(), "whiskey").build();


            Record gamma = defaultTable.recordBuilder()
                    .recordType(vRecordType1.getName())
                    .field(vfield1.getName(), "wodka").build();


            RecordId alplhaId = idGenerator.newRecordId();
            Record alpha = defaultTable.recordBuilder().id(alplhaId)
                    .recordType(cfRecordType.getName())
                    .field(recordField.getName(), beta)
                    .field(recordListField.getName(), Lists.newArrayList(beta, gamma)).build();
            expectEvent(CREATE, Table.RECORD.name, alplhaId, recordField.getId(), recordListField.getId());
            alpha = defaultTable.create(alpha);

View Full Code Here

                new QName(NS, "string"), Scope.NON_VERSIONED);


        FieldType recordListField = typeManager.createFieldType(typeManager.getValueType("LIST<RECORD>"),
                new QName(NS, "recordlist"), Scope.NON_VERSIONED);


        RecordType recordType = typeManager.recordTypeBuilder()
                .name(new QName(NS, "RecordType"))
                .field(linkField.getId(), false)
                .field(recordField.getId(), false)
                .field(record2Field.getId(), false)
                .field(stringField.getId(), false)
                .field(recordListField.getId(), false)
                .create();


        //
        // Change indexer conf
        //
        log.debug("Begin test V502");
        changeIndexUpdater("indexerconf_complexfields_deref.xml");


        //
        // Case 1: link field => record field => string field
        //
        {
            log.debug("Begin test V610");


            RecordId recordId = idGenerator.newRecordId();


            defaultTable
                    .recordBuilder()
                    .recordType(recordType.getName())
                    .field(linkField.getName(),
                            new Link(defaultTable
                                    .recordBuilder()
                                    .id(recordId)
                                    .recordType(recordType.getName())
                                    .field(recordField.getName(),
                                            defaultTable
                                                    .recordBuilder()
                                                    .recordType(recordType.getName())
                                                    .field(stringField.getName(), "bordeaux")
                                                    .build())
                                    .create()
                                    .getId()))
                    .create();


            commitIndex();


            verifyResultCount("+cfd_case1:bordeaux", 1);


            // perform update
            log.debug("Begin test V611");


            defaultTable
                    .recordBuilder()
                    .id(recordId)
                    .field(recordField.getName(),
                            defaultTable
                                    .recordBuilder()
                                    .recordType(recordType.getName())
                                    .field(stringField.getName(), "bordooo")
                                    .build())
                    .update();


            commitIndex();


            verifyResultCount("+cfd_case1:bordooo", 1);
            verifyResultCount("+cfd_case1:bordeaux", 0);
        }


        //
        // Case 2: link field => record field => link field => string field
        //
        {
            log.debug("Begin test V620");


            RecordId recordId1 = idGenerator.newRecordId();
            RecordId recordId2 = idGenerator.newRecordId();


            defaultTable
                    .recordBuilder()
                    .recordType(recordType.getName())
                    .field(linkField.getName(),
                            new Link(defaultTable
                                    .recordBuilder()
                                    .id(recordId1)
                                    .recordType(recordType.getName())
                                    .field(recordField.getName(),
                                            defaultTable
                                                    .recordBuilder()
                                                    .recordType(recordType.getName())
                                                    .field(linkField.getName(),
                                                            new Link(defaultTable
                                                                    .recordBuilder()
                                                                    .id(recordId2)
                                                                    .recordType(recordType.getName())
                                                                    .field(stringField.getName(), "beaujolais")
                                                                    .create()
                                                                    .getId()))
                                                    .build())
                                    .create()
                                    .getId()))
                    .create();


            commitIndex();


            verifyResultCount("+cfd_case2:beaujolais", 1);


            // perform update
            log.debug("Begin test V621");


            defaultTable
                    .recordBuilder()
                    .id(recordId2)
                    .field(stringField.getName(), "booojolais")
                    .update();


            commitIndex();


            verifyResultCount("+cfd_case2:booojolais", 1);
            verifyResultCount("+cfd_case2:beaujolais", 0);
        }


        //
        // Case 3: record field => link field => string field
        //
        {
            log.debug("Begin test V630");


            RecordId recordId = idGenerator.newRecordId();


            defaultTable
                    .recordBuilder()
                    .recordType(recordType.getName())
                    .field(record2Field.getName(),
                            defaultTable
                                    .recordBuilder()
                                    .recordType(recordType.getName())
                                    .field(linkField.getName(),
                                            new Link(defaultTable
                                                    .recordBuilder()
                                                    .id(recordId)
                                                    .recordType(recordType.getName())
                                                    .field(stringField.getName(), "bourgogne")
                                                    .create()
                                                    .getId()))
                                    .build())
                    .create();


            commitIndex();


            verifyResultCount("+cfd_case3:bourgogne", 1);


            // perform an update
            log.debug("Begin test V631");


            defaultTable
                    .recordBuilder()
                    .id(recordId)
                    .field(stringField.getName(), "boerhonje")
                    .update();


            commitIndex();


            verifyResultCount("+cfd_case3:boerhonje", 1);
            verifyResultCount("+cfd_case3:bourgogne", 0);
        }


        //
        // Case 4: link field => list<record> field => link field => string field
        //
        {
            log.debug("Begin test V640");


            RecordId recordId1 = idGenerator.newRecordId();
            RecordId recordId2 = idGenerator.newRecordId();
            RecordId recordId3 = idGenerator.newRecordId();
            RecordId recordId4 = idGenerator.newRecordId();


            defaultTable
                    .recordBuilder()
                    .recordType(recordType.getName())
                    .id(recordId1)
                    .field(linkField.getName(),
                            new Link(defaultTable
                                    .recordBuilder()
                                    .id(recordId2)
                                    .recordType(recordType.getName())
                                    .field(recordListField.getName(),
                                            Arrays.asList(
                                                    defaultTable
                                                            .recordBuilder()
                                                            .id(recordId3)
                                                            .recordType(recordType.getName())
                                                            .field(linkField.getName(),
                                                                    new Link(defaultTable
                                                                            .recordBuilder()
                                                                            .id(recordId3)
                                                                            .recordType(recordType.getName())
                                                                            .field(stringField.getName(), "champagne")
                                                                            .create()
                                                                            .getId()))
                                                            .build(),
                                                    defaultTable
                                                            .recordBuilder()
                                                            .id(recordId4)
                                                            .recordType(recordType.getName())
                                                            .field(linkField.getName(),
                                                                    new Link(defaultTable
                                                                            .recordBuilder()
                                                                            .id(recordId4)
                                                                            .recordType(recordType.getName())
                                                                            .field(stringField.getName(), "languedoc")
                                                                            .create()
                                                                            .getId()))
                                                            .build()
                                            ))
                                    .create()
                                    .getId()))
                    .create();


            commitIndex();


            verifyResultCount("+cfd_case4:champagne", 1);
            verifyResultCount("+cfd_case4:languedoc", 1);


            // perform an update
            log.debug("Begin test V640");


            defaultTable
                    .recordBuilder()
                    .id(recordId3)
                    .field(stringField.getName(), "sampanje")
                    .update();


            commitIndex();


            verifyResultCount("+cfd_case4:sampanje", 1);
            verifyResultCount("+cfd_case4:languedoc", 1);
            verifyResultCount("+cfd_case4:champagne", 0);


            // perform another update */
            log.debug("Begin test V641");


            defaultTable
                    .recordBuilder()
                    .id(recordId2)
                    .recordType(recordType.getName())
                    .field(recordListField.getName(),
                            Arrays.asList(defaultTable
                                    .recordBuilder()
                                    .recordType(recordType.getName())
                                    .field(linkField.getName(), new Link(recordId3))
                                    .build()))
                    .update();


            commitIndex();


            verifyResultCount("+cfd_case4:sampanje", 1);
            verifyResultCount("+cfd_case4:languedoc", 0);
        }


        //
        // Case 5: link field => record field => record field => string field
        //
        {
            log.debug("Begin test V650");


            RecordId recordId1 = idGenerator.newRecordId();
            RecordId recordId2 = idGenerator.newRecordId();


            defaultTable
                    .recordBuilder()
                    .id(recordId1)
                    .recordType(recordType.getName())
                    .field(linkField.getName(),
                            new Link(defaultTable
                                    .recordBuilder()
                                    .id(recordId2)
                                    .recordType(recordType.getName())
                                    .field(recordField.getName(),
                                            defaultTable
                                                    .recordBuilder()
                                                    .recordType(recordType.getName())
                                                    .field(recordField.getName(),
                                                            defaultTable
                                                                    .recordBuilder()
                                                                    .recordType(recordType.getName())
                                                                    .field(stringField.getName(), "loire")
                                                                    .build())
                                                    .build())
                                    .create()
                                    .getId()))
                    .create();


            commitIndex();


            verifyResultCount("+cfd_case5:loire", 1);


            // perform an update
            log.debug("Begin test V651");


            defaultTable
                    .recordBuilder()
                    .id(recordId2)
                    .recordType(recordType.getName())
                    .field(recordField.getName(),
                            defaultTable
                                    .recordBuilder()
                                    .recordType(recordType.getName())
                                    .field(recordField.getName(),
                                            defaultTable
                                                    .recordBuilder()
                                                    .recordType(recordType.getName())
                                                    .field(stringField.getName(), "lwaare")
                                                    .build())
                                    .build())
                    .update();

View Full Code Here

    protected RecordType processPost(PostAction<RecordType> postAction) {
        if (!postAction.getAction().equals("create")) {
            throw new ResourceException("Unsupported POST action: " + postAction.getAction(), BAD_REQUEST.getStatusCode());
        }


        RecordType recordType = postAction.getEntity();
        try {
            recordType = typeManager.createRecordType(recordType);
        } catch (RecordTypeExistsException e) {
            throw new ResourceException(e, CONFLICT.getStatusCode());
        } catch (Exception e) {

View Full Code Here

    @Produces("application/json")
    public Entity<RecordType> get(@PathParam("id") String id, @PathParam("version") Long version,
            @Context UriInfo uriInfo) {
        try {
            SchemaId schemaId = idGenerator.getSchemaId(id);
            RecordType recordType = typeManager.getRecordTypeById(schemaId, version);
            return Entity.create(recordType, uriInfo);
        } catch (RecordTypeNotFoundException e) {
            throw new ResourceException(e, NOT_FOUND.getStatusCode());
        } catch (Exception e) {
            throw new ResourceException("Error loading record type with id " + id + ", version " + version, e,

View Full Code Here


        if (filter.getRecordType() == null) {
            throw new IllegalArgumentException("A RecordTypeFilter should at least specify the record type name.");
        }


        RecordType recordType = repository.getTypeManager().getRecordTypeByName(filter.getRecordType(), null);


        RecordTypeFilter.Operator operator =
                filter.getOperator() != null ? filter.getOperator() : RecordTypeFilter.Operator.EQUALS;


        switch (operator) {
            case EQUALS:
                Filter nameFilter = createRecordTypeFilter(recordType.getId());


                Filter versionFilter = null;
                if (filter.getVersion() != null) {
                    versionFilter = new SingleColumnValueFilter(RecordCf.DATA.bytes,
                            RecordColumn.NON_VERSIONED_RT_VERSION.bytes, CompareFilter.CompareOp.EQUAL,
                            Bytes.toBytes(filter.getVersion()));
                }


                if (versionFilter == null) {
                    result = nameFilter;
                } else {
                    FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ALL);
                    list.addFilter(nameFilter);
                    list.addFilter(versionFilter);
                    result = list;
                }


                break;
            case INSTANCE_OF:
                Set<SchemaId> subtypes = repository.getTypeManager().findSubtypes(recordType.getId());
                FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE);
                list.addFilter(createRecordTypeFilter(recordType.getId()));
                for (SchemaId subType : subtypes) {
                    list.addFilter(createRecordTypeFilter(subType));
                }
                result = list;
                break;

View Full Code Here


    @POST
    @Consumes("application/json")
    @Produces("application/json")
    public Response post(PostAction<RecordType> postAction, @Context UriInfo uriInfo) {
        RecordType recordType = processPost(postAction);
        URI uri = uriInfo.getBaseUriBuilder().path(RecordTypeResource.class).
                queryParam("ns.n", recordType.getName().getNamespace()).
                build("n$" + recordType.getName().getName());
        return Response.created(uri).entity(Entity.create(recordType, uriInfo)).build();
    }

View Full Code Here

    }


    @Test
    public void testCreateEmpty() throws Exception {
        QName name = new QName("testNS", "testCreateEmpty");
        RecordType recordType = typeManager.newRecordType(name);
        recordType = typeManager.createRecordType(recordType);
        assertEquals(Long.valueOf(1), recordType.getVersion());
        RecordType recordType2 = typeManager.getRecordTypeByName(name, null);
        assertEquals(recordType, recordType2);
    }

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.