Exemple #1
0
    def _predicate_orm_attr(self, iri):

        try:
            table_iri_str, _, colspec = iri.partition('#')
        except AttributeError:
            raise TypeError(u'invalid predicate IRI {!r}: not a string'
                             .format(iri))

        if not table_iri_str or not colspec:
            raise ValueError(u'invalid predicate IRI {!r}:'
                              u' does not match either format {!r}'
                              .format(iri,
                                      ('table#colname',
                                       'table#ref-colname[;colname]...')))

        table_iri = _rdf.URIRef(table_iri_str)

        if colspec.startswith('ref-'):
            cols = frozenset(_pct_decoded(colname)
                             for colname in colspec[4:].split(';'))
            try:
                prop = self._orm_relationships[table_iri][cols]
            except KeyError:
                raise ValueError('unknown reference property {!r}'.format(iri))

        else:
            col = _pct_decoded(colspec)
            try:
                prop = self._orm_columns_properties[table_iri][col]
            except KeyError:
                raise ValueError('unknown literal property {!r}'.format(iri))

        return prop.class_attribute
Exemple #2
0
    def _predicate_orm_attr(self, iri):

        try:
            table_iri_str, _, colspec = iri.partition('#')
        except AttributeError:
            raise TypeError(
                u'invalid predicate IRI {!r}: not a string'.format(iri))

        if not table_iri_str or not colspec:
            raise ValueError(
                u'invalid predicate IRI {!r}:'
                u' does not match either format {!r}'.format(
                    iri, ('table#colname', 'table#ref-colname[;colname]...')))

        table_iri = _rdf.URIRef(table_iri_str)

        if colspec.startswith('ref-'):
            cols = frozenset(
                _pct_decoded(colname) for colname in colspec[4:].split(';'))
            try:
                prop = self._orm_relationships[table_iri][cols]
            except KeyError:
                raise ValueError('unknown reference property {!r}'.format(iri))

        else:
            col = _pct_decoded(colspec)
            try:
                prop = self._orm_columns_properties[table_iri][col]
            except KeyError:
                raise ValueError('unknown literal property {!r}'.format(iri))

        return prop.class_attribute
Exemple #3
0
    def _parse_row_node(self, node):

        try:
            table_iri_str, _, pkeyspec = node.rpartition('/')
        except AttributeError:
            raise TypeError(u'invalid row node {!r}: not a string'
                             .format(node))

        if not table_iri_str or '=' not in pkeyspec:
            raise ValueError\
                   (u'invalid row node {!r}: does not match format {!r}'
                     .format(node, 'table/colname=value[;colname=value]...'))

        table_iri = _rdf.URIRef(table_iri_str)

        if table_iri in self._orm_bnode_tables:
            if not isinstance(node, _rdf.BNode):
                raise ValueError('invalid node type {!r} for blank node table'
                                  ' {!r}: not blank node'
                                  .format(node.__class__, table_iri))
        else:
            if not isinstance(node, _rdf.URIRef):
                raise ValueError('invalid node type {!r} for IRI node table'
                                  ' {!r}: not IRI node'
                                  .format(node.__class__, table_iri))

        pkey = {}
        cols_props = self._orm_columns_properties[table_iri]
        cols_datatypes = self._orm_columns_rdf_datatypes[table_iri]
        for name_irisafe, value_irisafe in (item.split('=')
                                            for item in pkeyspec.split(';')):
            colname = _pct_decoded(name_irisafe)
            value_rdf = _rdf.Literal(_pct_decoded(value_irisafe),
                                     datatype=cols_datatypes[colname])
            pkey[cols_props[colname].class_attribute] = \
                _common.sql_literal_from_rdf(value_rdf)

        return table_iri, pkey
Exemple #4
0
    def _parse_row_node(self, node):

        try:
            table_iri_str, _, pkeyspec = node.rpartition('/')
        except AttributeError:
            raise TypeError(
                u'invalid row node {!r}: not a string'.format(node))

        if not table_iri_str or '=' not in pkeyspec:
            raise ValueError\
                   (u'invalid row node {!r}: does not match format {!r}'
                     .format(node, 'table/colname=value[;colname=value]...'))

        table_iri = _rdf.URIRef(table_iri_str)

        if table_iri in self._orm_bnode_tables:
            if not isinstance(node, _rdf.BNode):
                raise ValueError('invalid node type {!r} for blank node table'
                                 ' {!r}: not blank node'.format(
                                     node.__class__, table_iri))
        else:
            if not isinstance(node, _rdf.URIRef):
                raise ValueError('invalid node type {!r} for IRI node table'
                                 ' {!r}: not IRI node'.format(
                                     node.__class__, table_iri))

        pkey = {}
        cols_props = self._orm_columns_properties[table_iri]
        cols_datatypes = self._orm_columns_rdf_datatypes[table_iri]
        for name_irisafe, value_irisafe in (item.split('=')
                                            for item in pkeyspec.split(';')):
            colname = _pct_decoded(name_irisafe)
            value_rdf = _rdf.Literal(_pct_decoded(value_irisafe),
                                     datatype=cols_datatypes[colname])
            pkey[cols_props[colname].class_attribute] = \
                _common.sql_literal_from_rdf(value_rdf)

        return table_iri, pkey