Package org.lilyproject.repository.api

Examples of org.lilyproject.repository.api.Record


     */
    @Test
    public void testScannerAndDeletedRecords() throws Exception {
        for (int i = 0; i < 5; i++) {
            RecordId id = idGenerator.newRecordId("ScanDeleteTest-" + i);
            Record record = repository.newRecord(id);
            record.setRecordType(recordType1.getName());
            String value = "dummy";
            record.setField(fieldType1.getName(), value);
            repository.create(record);
        }

        RecordScan scan = new RecordScan();
        scan.setStartRecordId(idGenerator.newRecordId("ScanDeleteTest-"));
View Full Code Here


        }
    }

    @Test
    public void testMetadataSimpleStoreLoad() throws Exception {
        Record record = repository.newRecord();
        record.setRecordType(recordType1.getName());
        record.setField(fieldType1.getName(), "field value");

        Metadata metadata = new MetadataBuilder().value("field1", "value1").value("field2", "value2").build();

        record.setMetadata(fieldType1.getName(), metadata);
        assertEquals(2, record.getMetadataMap().get(fieldType1.getName()).getMap().size());

        record = repository.create(record);

        // Check state of returned record object
        Metadata returnedMetadata = record.getMetadata(fieldType1.getName());
        assertNotNull(returnedMetadata);
        assertEquals(2, returnedMetadata.getMap().size());
        assertEquals("value1", returnedMetadata.get("field1"));
        assertEquals("value2", returnedMetadata.get("field2"));

        // Check state when freshly reading record
        record = repository.read(record.getId());

        assertEquals(1, record.getMetadataMap().size());
        Metadata readMetadata = record.getMetadataMap().get(fieldType1.getName());
        assertNotNull(readMetadata);
        assertEquals(2, readMetadata.getMap().size());
        assertEquals("value1", readMetadata.get("field1"));
        assertEquals("value2", readMetadata.get("field2"));
    }
View Full Code Here

        testValues.add(Pair.create(new ByteArray("A".getBytes()), new ByteArray("B".getBytes())));

        for (Pair testValue : testValues) {
            String ctx = "testing " + testValue.getV1() + " of type " + testValue.getV1().getClass().getName();

            Record record = repository.newRecord();
            record.setRecordType(recordType1.getName());
            record.setField(fieldType2.getName(), new Integer(1));
            record.setMetadata(fieldType2.getName(), new MetadataBuilder()
                    .object("somefield", testValue.getV1())
                    .build());
            record = repository.create(record);

            // test the type of the metadata has been retained
            assertEquals(ctx, testValue.getV1().getClass(),
                    record.getMetadata(fieldType2.getName()).getMap().get("somefield").getClass());

            // do dummy update, should not create new version
            //  (apparently, this also works fine for the float & double tests)
            record.setMetadata(fieldType2.getName(), new MetadataBuilder()
                    .object("somefield", testValue.getV1())
                    .build());
            record = repository.update(record);
            assertEquals(ctx, 1L, record.getVersion().longValue());

            // do update, should create new version
            record.setMetadata(fieldType2.getName(), new MetadataBuilder()
                    .object("somefield", testValue.getV2())
                    .build());
            record = repository.update(record);
            assertEquals(ctx, 2L, record.getVersion().longValue());

            // test the type of the metadata has been retained
            record = repository.read(record.getId());
            assertEquals(ctx, testValue.getV1().getClass(),
                    record.getMetadata(fieldType2.getName()).getMap().get("somefield").getClass());
        }
    }
View Full Code Here

        }
    }

    @Test
    public void testMetadataPartialUpdate() throws Exception {
        Record record = repository.newRecord();
        record.setRecordType(recordType1.getName());
        record.setField(fieldType1.getName(), "field value");

        Metadata metadata = new MetadataBuilder()
                .value("field1", "value1")
                .value("field2", "value2")
                .value("field3", "value3").build();

        record.setMetadata(fieldType1.getName(), metadata);
        record = repository.create(record);
        RecordId recordId = record.getId();

        // Now update metadata:
        //   - field1 is left unchanged and not specified
        //   - field2 is updated
        //   - field3 is deleted
        //   - a new field4 is added
        metadata = new MetadataBuilder()
                .value("field2", "value2a")
                .delete("field3")
                .value("field4", "value4").build();

        record = repository.newRecord(recordId);
        record.setMetadata(fieldType1.getName(), metadata);
        record = repository.update(record);

        // Check state of returned record object
        Metadata returnedMetadata = record.getMetadata(fieldType1.getName());
        assertNotNull(returnedMetadata);
        assertEquals(2, returnedMetadata.getMap().size());
        assertEquals("value2a", returnedMetadata.get("field2"));
        assertEquals("value4", returnedMetadata.get("field4"));
        assertEquals(0, returnedMetadata.getFieldsToDelete().size());

        // Check state when freshly reading record
        record = repository.read(record.getId());

        Metadata readMetadata = record.getMetadataMap().get(fieldType1.getName());
        assertNotNull(readMetadata);
        assertEquals(3, readMetadata.getMap().size());
        assertEquals("value1", readMetadata.get("field1"));
        assertEquals("value2a", readMetadata.get("field2"));
        assertEquals("value4", readMetadata.get("field4"));
View Full Code Here

            throws InterruptedException, RepositoryException, JsonFormatException {
        LRepository repository = context.repository;
        Namespaces namespaces = context.namespaces;
        JsonNode node = handle.node;

        Record record = readCommonRecordAspects(handle, context, true);

        String id = getString(node, "id", null);
        if (id != null) {
            record.setId(repository.getIdGenerator().fromString(id));
        }

        ArrayNode fieldsToDelete = getArray(node, "fieldsToDelete", null);
        if (fieldsToDelete != null) {
            for (int i = 0; i < fieldsToDelete.size(); i++) {
                JsonNode fieldToDelete = fieldsToDelete.get(i);
                if (!fieldToDelete.isTextual()) {
                    throw new JsonFormatException("fieldsToDelete should be an array of strings, encountered: " + fieldToDelete);
                } else {
                    QName qname = QNameConverter.fromJson(fieldToDelete.getTextValue(), namespaces);
                    record.getFieldsToDelete().add(qname);
                }
            }
        }

        ObjectNode attributes = getObject(node, "attributes", null);
        if (attributes != null) {
            Iterator<Map.Entry<String, JsonNode>> it = attributes.getFields();
            while(it.hasNext()) {
                Map.Entry<String, JsonNode> entry = it.next();
                record.getAttributes().put(entry.getKey(), entry.getValue().getTextValue());
            }
        }

        Map<QName, MetadataBuilder> metadataBuilders = null;
        ObjectNode metadata = getObject(node, "metadata", null);
        if (metadata != null) {
            metadataBuilders = new HashMap<QName, MetadataBuilder>();
            Iterator<Map.Entry<String, JsonNode>> it = metadata.getFields();
            while (it.hasNext()) {
                Map.Entry<String, JsonNode> entry = it.next();
                QName qname = QNameConverter.fromJson(entry.getKey(), namespaces);
                MetadataBuilder builder = readMetadata(entry.getValue(), qname);
                metadataBuilders.put(qname, builder);
            }
        }

        ObjectNode metadataToDelete = getObject(node, "metadataToDelete", null);
        if (metadataToDelete != null) {
            if (metadataBuilders == null) {
                metadataBuilders = new HashMap<QName, MetadataBuilder>();
            }

            Iterator<Map.Entry<String, JsonNode>> it = metadataToDelete.getFields();
            while (it.hasNext()) {
                Map.Entry<String, JsonNode> entry = it.next();
                QName qname = QNameConverter.fromJson(entry.getKey(), namespaces);
                MetadataBuilder builder = readMetadataToDelete(entry.getValue(), metadataBuilders.get(qname), qname);
                metadataBuilders.put(qname, builder);
            }
        }

        if (metadataBuilders != null) {
            for (Map.Entry<QName, MetadataBuilder> entry : metadataBuilders.entrySet()) {
                record.setMetadata(entry.getKey(), entry.getValue().build());
            }
        }

        return record;
    }
View Full Code Here

    protected Record readCommonRecordAspects(ValueHandle handle, ReadContext context, boolean topLevelRecord)
            throws JsonFormatException, InterruptedException, RepositoryException {
        LRepository repository = context.repository;
        Namespaces namespaces = context.namespaces;

        Record record = repository.getRecordFactory().newRecord();

        JsonNode typeNode = handle.node.get("type");
        if (typeNode != null) {
            if (typeNode.isObject()) {
                QName qname = QNameConverter.fromJson(JsonUtil.getString(typeNode, "name"), namespaces);
                Long version = JsonUtil.getLong(typeNode, "version", null);
                record.setRecordType(qname, version);
            } else if (typeNode.isTextual()) {
                record.setRecordType(QNameConverter.fromJson(typeNode.getTextValue(), namespaces));
            }
        }

        ObjectNode fields = getObject(handle.node, "fields", null);
        if (fields != null) {
            Iterator<Map.Entry<String, JsonNode>> it = fields.getFields();
            while (it.hasNext()) {
                Map.Entry<String, JsonNode> entry = it.next();

                QName qname = QNameConverter.fromJson(entry.getKey(), namespaces);
                FieldType fieldType = repository.getTypeManager().getFieldTypeByName(qname);
                ValueHandle subHandle = new ValueHandle(fields.get(entry.getKey()), "fields." + entry.getKey(),
                        fieldType.getValueType());
                Object value = readValue(subHandle, context);
                if (value != null) {
                    record.setField(qname, value);
                } else if (value == null && deleteNullFields() && topLevelRecord) {
                    record.delete(qname, true);
                }
            }
        }

        return record;
View Full Code Here

        }
    }

    @Test
    public void testValidateCreate() throws Exception {
        Record record = repository.newRecord();
        record.setRecordType(recordType3.getName(), 1L);
        record.setField(fieldType2.getName(), 123);
        repository.create(record);

        record = repository.newRecord();
        record.setRecordType(recordType3.getName(), 2L);
        record.setField(fieldType2.getName(), 123);
        try {
            if (avro) {
                System.out.println("Expecting InvalidRecordException");
            }
            repository.create(record);
            fail();
        } catch (InvalidRecordException expected) {
        }

        record = repository.newRecord();
        record.setRecordType(recordType3.getName(), 2L);
        record.setField(fieldType1.getName(), "abc");
        record.setField(fieldType2.getName(), 123);
    }
View Full Code Here

        record.setField(fieldType2.getName(), 123);
    }

    @Test
    public void testValidateUpdate() throws Exception {
        Record record = repository.newRecord();
        record.setRecordType(recordType3.getName(), 1L);
        record.setField(fieldType2.getName(), 123);
        record = repository.create(record);

        record.setRecordType(recordType3.getName(), 2L);
        record.setField(fieldType2.getName(), 567);
        try {
            if (avro) {
                System.out.println("Expecting InvalidRecordException");
            }
            repository.update(record, false, false);
            fail();
        } catch (InvalidRecordException expected) {
        }

        record.setField(fieldType1.getName(), "abc");
        repository.update(record, false, false);
    }
View Full Code Here

    }

    @Test
    public void testValidateMutableUpdate() throws Exception {
        // Nothing mandatory
        Record record = repository.newRecord();
        record.setRecordType(recordType3.getName(), 1L);
        record.setField(fieldType2.getName(), 123);
        record = repository.create(record);

        // Non-versioned field1 mandatory
        record = repository.newRecord(record.getId());
        record.setRecordType(recordType3.getName(), 2L);
        record.setField(fieldType1.getName(), "abc");
        repository.update(record, false, false); // record version 1

        // Mutable field3 mandatory
        record.setRecordType(recordType3.getName(), 3L);
        record.setField(fieldType1.getName(), "efg");
        try {
            if (avro) {
                System.out.println("Expecting InvalidRecordException");
            }
            repository.update(record, false, false);
            fail();
        } catch (InvalidRecordException expected) {
        }

        // Mutable field3 not mandatory
        record = repository.newRecord(record.getId());
        record.setRecordType(recordType3.getName(), 2L);
        record.setField(fieldType3.getName(), true);
        repository.update(record, false, false); // record version 2

        // Mutable field update of record version 1 with field3 mandatory
        // Field3 already exists, but in record version 2 not version 1
        record = repository.newRecord(record.getId());
        record.setRecordType(recordType3.getName(), 4L);
        record.setField(fieldType6.getName(), "zzz");
        record.setVersion(1L);
        try {
            if (avro) {
                System.out.println("Expecting InvalidRecordException");
            }
            repository.update(record, true, false);
            fail();
        } catch (InvalidRecordException expected) {
        }
        record.setField(fieldType3.getName(), false);
        repository.update(record, true, false);
    }
View Full Code Here

                recordEvent.setTableName(getTableName());
                if (record.hasAttributes()) {
                    recordEvent.getAttributes().putAll(record.getAttributes());
                }

                Record newRecord = record.cloneRecord();
                newRecord.setId(recordId);

                for (RecordUpdateHook hook : updateHooks) {
                    hook.beforeCreate(newRecord, this, fieldTypes, recordEvent);
                }

                Set<BlobReference> referencedBlobs = new HashSet<BlobReference>();
                Set<BlobReference> unReferencedBlobs = new HashSet<BlobReference>();

                Put put = buildPut(newRecord, version, fieldTypes, recordEvent, referencedBlobs, unReferencedBlobs, newOcc);

                // Make sure the record type changed flag stays false for a newly
                // created record
                recordEvent.setRecordTypeChanged(false);
                Long newVersion = newRecord.getVersion();
                if (newVersion != null) {
                    recordEvent.setVersionCreated(newVersion);
                }

                // Reserve blobs so no other records can use them
                reserveBlobs(null, referencedBlobs);

                put.add(RecordCf.DATA.bytes, RecordColumn.PAYLOAD.bytes, recordEvent.toJsonBytes());
                boolean success = recordTable.checkAndPut(put.getRow(), RecordCf.DATA.bytes, RecordColumn.OCC.bytes,
                        oldOccBytes, put);
                if (!success) {
                    throw new RecordExistsException(recordId);
                }

                // Remove the used blobs from the blobIncubator
                blobManager.handleBlobReferences(recordId, referencedBlobs, unReferencedBlobs);

                newRecord.setResponseStatus(ResponseStatus.CREATED);
                removeUnidirectionalState(newRecord);
                return newRecord;

            } catch (IOException e) {
                throw new RecordException("Exception occurred while creating record '" + recordId + "' in HBase table",
View Full Code Here

TOP

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

Copyright © 2018 www.massapicom. All rights reserved.
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.