Get ready to experience unmatched flexibility and power.
Here is a quick overview of what univocity can do for you.

Import external information into your database

With univocity, the information you need can be extracted, transformed, migrated and synchronized easily. It doesn't matter how it is stored!

Our documentation provides fully working examples and tutorials for your team to learn all about the powerful features available


Easy mapping definition

With the fluent API univocity provides, you need very little to accomplish a lot.

        EntityMapping entityMapping = dataStoreMapping.map("source_entity", "destination_entity");
        entityMapping.identity().associate("pk1", "pk2").toGeneratedId("id");
        entityMapping.value().copy("name", "quantity", "price").to("description", "amount", "price");
    

Data management

univocity is the only data integration solution that cares about your data once it has been mapped. You can easily manage how to handle data updates, and leverage the automatic update detection and synchronization features to deliver extremely complex mapping solutions in no time.

        entityMapping.persistence().usingMetadata().deleteAbsent().updateModified().insertNewRows();
    

Information integrity

Decompose your input data and map it into a new schema. univocity manages referential constraints and generated keys, even when information is obtained from irregular data (such as words in free text). It doesn't matter how data is stored, univocity can transform it whilst maintaining information integrity.

See it in action!

Flexibility

Have access to each step of the mapping process and tailor your data flow from one end to another.

        entityMapping.addOutputRowReader(new RowReader() {

                @Override
                public void processRow(Object[] inputRow, Object[] outputRow, RowMappingContext context) {
                    // modify data as it is processed               
                    String name = context.getOutputValue("name", String.class);
                    if(name != null){
                        context.setOutputValue("name", name.toUpperCase());
                    } else {
                        context.discardRow();
                    }

                    // use any objects accessible from within your application 
                    context.setOutputValue("processed_date", new Date());
                    context.setOutputValue("username", session.getAttribute("currentSessionUser"));
                }
            });
    

Convenience

Use components from your existing application: are you using a distributed cache? Do you need to use data from external services, or from objects in your system? You can make univocity use these and any other resources from your application stack.

            engine.addFunction(EngineScope.CYCLE, "getAccountBalance", new FunctionCall<BigDecimal, String>() {
                @Override
                public BigDecimal execute(String accountNumber) {
                    return yourAccountService.findAccount(accountNumber).getBalance();
                }
            });

            ...

            entityMapping.value().copy("accountNumber").to("balance").readingWith("getAccountBalance");
    

Control

univocity gives you control over what records to update, when and how.

        engine.disableUpdateOnRecords("myEntity", datasetWithRecords);
        engine.executeCycle();

        ...

        engine.enableUpdateOnAllRecords("myEntity");
        engine.executeCycle();

        ...
    

No limitations

Data inputs and outputs can be anything from databases and webservices to flat files. univocity lets you create custom data entities, data stores and queries. Any database that has a JDBC driver will work out of the box with univocity.

        public class MyEntity implements com.univocity.api.entity.custom.CustomDataEntity {

            private final MyDataStore dataStore;
            ...

            public com.univocity.api.entity.custom.ReadingProcess preareToRead(String[] fieldNames){
                ...
            }

            public com.univocity.api.entity.custom.WritingProcess prepareToWrite(String[] fieldNames){
                ...
            }

        }
    

Lightweight

Manage the use of potentially slow operations and determine when to invoke them using the various scope levels provided by univocity.

        engine.addQuery(EngineScope.APPLICATION, "findAccountType")
                    .onDataStore("csvDataStore")
                    .fromString("SELECT account_type_id FROM account_type WHERE code = :accountTypeCode")
                    .returnSingleValue()
                    .directly()
                    .onErrorAbort();

        ...

        entityMapping.value().copy("{findAccountType('CHEQUE')}").to("acctyp");
    

And much, much more! Check our tutorials, documentation and source code