Skip to main content

Cube for data input/output, import and export

Project description


Cube for data input/output, import and export

Massive Store

The Massive Store is a CW store used to push massive amount
of data using pure SQL logic, thus avoiding CW checks.
It is faster than other CW stores (it does not check eid at each step,
it use COPY FROM method), but is less safe (no data integrity securities),
and does not return an eid while using create_entity function.

WARNING: This store may be only used with PostgreSQL for now, as it
relies on the COPY FROM method, and on specific PostgreSQL tables
to get all the indexes.

Workflow of Massive Store

The Massive Store workflow is the following:

* Drop indexes and constraints from the meta-data tables (entities, is_instance_of, ...);

* Insertion of data:

* using the `create_entity` function for entities;

* using the `relate` function for relations;

* using the `related_by_iid` function for relations based on external identifiers;

* each insertion of a rtype that has not been seen yet will trigger the
creation of a temporary table for this rtype, to store the results.

* each insertion of an etype that has not been seen yet will remove all
the indexes/constraints on the entity table.

* At a given point, one should call the `flush` method:

* it will flush the entities data into the database based on `COPY_FROM`.

* it will flush the relations data into the database based on `COPY_FROM`.

* it will flush the relations-iid data into the database based on `COPY_FROM`.

* it will create the metadata (entities, ...) for the insered entities.

* it will commit.

* If some relations are created based on external identifiers (`relate_by_iid`),
the conversion should be manually done using the `convert_relations` method.

* At the end of the insertion, one should call the `cleanup` method:

* it will re-create the indexes/constraints/primary key for the entities/relations tables.

* it will re-create the indexes/constraints on the meta-data tables.

* it will remove temporary tables and internal store tables.

Entities/Relations in Massive Store

Due to the technical constraints on the database insertion, there are some following specific points to notice:

* a `create_entity` call will return an entity with a specific `eid`. Eids are automatically dealt with
by the Massive Store (it will fetch for a given range of eids for its internal use), but you can
pass a specific eid in the kwargs of the `create_entity` call to bypass the automatic assignation of an eid.

* inlined-relations are not supported in the `relate` method.

A buffer will be created for the call to the PostgreSQL `COPY_FROM` clause.
If the separator used for the creation of this tabular file is found in the data of the entities (or relations),
it will be replace by the `replace_sep` of the store (default is to '').

Basic use of Massive Store

A simple script using the Massive Store::

# Initialize the store
store = MassiveObjectStore(session)
# Initialize the Relation table
store.init_rtype_table('Person', 'lives', 'Location')

# Import logic
entity = store.create_entity('Person', ...)
entity = store.create_entity('Location', ...)

# Flush the data in memory to sql database

# Import logic
entity = store.create_entity('Person', ...)
entity = store.create_entity('Location', ...)
# Person_iid and location_iid are unique iid that are data dependant (e.g URI)
store.relate_by_iid(person_iid, 'lives', location_iid)

# Flush the data in memory to sql database

# Convert the relation
store.convert_relations('Person', 'lives', 'Location')

# Clean the store / rebuild indexes

In this case, iid_subj and iid_obj represent an unique id
(e.g. uri, or id from the imported database) that can be used to create
relations after importing entities.

Advanced use of Massive Store

The simple and default use of the Massive Store is conservative to avoid issues in meta-data management.
However it is possible to increase insertion speed:

* the flushing of meta-data could be costly if done too many times.
A good practive is to do only once at the end of the import.
For doing so, you should set `autoflush_metadata` to False in the store creation,
and you should call the `flush_meta_data' at the end of the import
(**but before the call to `cleanup`**).

* you may avoid to commit at each flush, by setting `commit_at_flush` to False in the store creation.
Thus you should explicitely call the `commit` method at least once **before flushing the meta data and
cleaning up the store**.

* you could avoid dropping the different indexes and constraints using the `drop_index` attribute
during the store creation.

* you could set a different starting point of the eids sequence using the `eids_seq_start` attribute
during the store creation.

* additional callbacks could be given to deal with commit and rollback (`on_commit_callback` and

Example of advanced use of Massive Store::

store = MassiveObjectStore(session,
store.init_rtype_table('Location', 'names', 'LocationName')
for ind, infos in enumerate(ucsvreader(open(dumpname))):
entity = {'name': infos[1], ...}
entity['my_inlined_relation'] = my_dict.get(infos[2])
entity = store.create_entity('Location', **entity)
store.relate_by_iid(entity.cwuri, 'my_external_relation', infos[3])
if ind and ind % 200000 == 0:
store.convert_relations('Location', 'my_external_relation', 'Location',
'cwuri', 'cwuri')

Restoring a database after Massive Store failure

The Massive Store remove some constraints and indexes that are automatically
rebuild during the `cleanup` call. If there is an error during the import
process, you could still call to the `cleanup` method, or even recreate after
the failure another store and call the `cleanup` method of this store.

The Massive Store create the following tables for its internal use:

* `dataio_initialized`: information on the initialized etype/rtype tables.

* `dataio_constraints`: the queries that may be used to restore the constraints/indexes
for the different etype/rtype tables.

* `dataio_metadata`: the etypes that have already have their meta-data pushed.

Slave Mode

A slave mode is available for parallel use of the Massive Store:

* a Massive Store (*master*) should be created.

* for all the possible etype/rtype that may be encoutered during the import,
the `init_etype_table`/`init_relation_table` methods of the *master* store
should be called.

* different *slave* stores could be created using the `slave_mode` attribute
during the store creation. The `autoflush_metadata` attribute should be setted to False.

* each *slave* store could be used in a different thread, for creating entity
and relation, and should only call to its `flush` and `commit` methods.

* The *master* store should call its `flush_meta_data` and `cleanup` methods
at the end of the import.

RDF Store

The RDF Store is used to import RDF data into a CubicWeb data, based on a Yams <-> RDF schema conversion.
The conversion rules are stored in a XY structure.

Building an XY structure

You have to create a file (usually called ``) in your cube, and import the dataio version of xy::

from cubes.dataio import xy

You have to register the different prefixes (common prefixes as skos or foaf are already registered)::

xy.register_prefix('diseasome', '')

By default, the entity type is based on the rdf property "rdf:type", but you may changed it using::


It is also possible to give a specific callback to determine the entity type from the rdf properties::

def _rameau_etype_callback(rdf_properties):
if 'skos:inScheme' in rdf_properties and 'skos:prefLabel' in rdf_properties:
return 'Rameau'


The URI is fetched from the "rdf:about" property, and can be normalized using a specific callback::

def normalize_uri(uri):
if uri.endswith('.rdf'):
return uri[:-4]
return uri


Defining the conversion rules

Then, you may write the conversion rules:

- xy.add_equivalence allows you to add a basic equivalence between entity type / attribute / relations,
and RDF properties. You may use "*" as a wild cart in the Yams part.
E.g. for entity types::

xy.add_equivalence('Gene', 'diseasome:genes')
xy.add_equivalence('Disease', 'diseasome:diseases')

E.g. for attributes::

xy.add_equivalence('* name', 'diseasome:name')
xy.add_equivalence('* label', 'rdfs:label')
xy.add_equivalence('* label', 'diseasome:label')
xy.add_equivalence('* class_degree', 'diseasome:classDegree')
xy.add_equivalence('* size', 'diseasome:size')

E.g. for relations::

xy.add_equivalence('Disease close_match ExternalUri', 'diseasome:classes')
xy.add_equivalence('Disease subtype_of Disease', 'diseasome:diseaseSubtypeOf')
xy.add_equivalence('Disease associated_genes Gene', 'diseasome:associatedGene')
xy.add_equivalence('Disease chromosomal_location ExternalUri', 'diseasome:chromosomalLocation')
xy.add_equivalence('* sameas ExternalUri', 'owl:sameAs')
xy.add_equivalence('Gene gene_id ExternalUri', 'diseasome:geneId')
xy.add_equivalence('Gene bio2rdf_symbol ExternalUri', 'diseasome:bio2rdfSymbol')

- A base URI can be given to automatically determine if a Resource should be considered
as an external URI or an internal relation::


A more complex logic can be used by giving a specific callback::

def externaluri_callback(uri):
if uri.startswith(''):
if uri.endswith('disease') or uri.endswith('gene'):
return False
return True
return True


The values of attributes are built based on the Yams type. But you could use a specific
callback to compute the correct values from the rdf properties::

def _convert_date(_object, datetime_format='%Y-%m-%d'):
""" Convert an rdf value to a date """
return datetime.strptime(_object.format(), datetime_format)
return None

xy.register_attribute_callback('Date', _convert_date)


def format_isbn(rdf_properties):
if 'bnf-onto:isbn' in rdf_properties:
isbn = rdf_properties['bnf-onto:isbn'][0]
isbn = [i for i in isbn if i in '0123456789']
return int(''.join(isbn)) if isbn else None

xy.register_attribute_callback('Manifestation formatted_isbn', format_isbn)

Importing data

Data may thus be imported using the "import-rdf" command of cubicweb-ctl::

cubicweb-ctl import-rdf <my-instance> <filer-or-folder>

The default library used for reading the data is "rdflib" but one may use "librdf" using the "--lib" option.

It is also possible to force the rdf-format (it is automatically determined, but this may sometimes lead to errors),
using the "--rdf-format" option.

Exporting data

The view 'rdf' may be called and will create a RDF file from the result set. It is a modified version of the
CubicWeb RDFView, that take into account the more complex conversion rules from the dataio cube.
The format can also be forced (default is XML) using the "--format" option in the url (xml, n3 or nt).


Examples of use of dataio rdf import could be found in the nytimes and diseasome cubes.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

cubicweb-dataio-0.3.3.tar.gz (41.4 kB view hashes)

Uploaded Source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page