@lde/pipeline-void 0.19.1 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +52 -42
  2. package/dist/stage.d.ts +41 -16
  3. package/dist/stage.d.ts.map +1 -1
  4. package/dist/stage.js +80 -29
  5. package/package.json +2 -2
  6. package/queries/class-properties-objects.rq +9 -5
  7. package/queries/class-properties-subjects.rq +11 -7
package/README.md CHANGED
@@ -4,60 +4,70 @@ Extensions to [@lde/pipeline](../pipeline) for VoID (Vocabulary of Interlinked D
4
4
 
5
5
  ## Stage factories
6
6
 
7
- ### Global stages (one CONSTRUCT query per dataset):
7
+ ### `voidStages(options?)`
8
8
 
9
- | Factory | Query |
10
- | ------------------------- | ------------------------------------------------------------------------------------------------------------------ |
11
- | `classPartitions()` | [`class-partition.rq`](src/queries/class-partition.rq) — Classes with entity counts |
12
- | `classPropertySubjects()` | [`class-properties-subjects.rq`](src/queries/class-properties-subjects.rq) — Properties per class (subject counts) |
13
- | `classPropertyObjects()` | [`class-properties-objects.rq`](src/queries/class-properties-objects.rq) — Properties per class (object counts) |
14
- | `countDatatypes()` | [`datatypes.rq`](src/queries/datatypes.rq) — Dataset-level datatypes |
15
- | `countObjectLiterals()` | [`object-literals.rq`](src/queries/object-literals.rq) — Literal object counts |
16
- | `countObjectUris()` | [`object-uris.rq`](src/queries/object-uris.rq) — URI object counts |
17
- | `countProperties()` | [`properties.rq`](src/queries/properties.rq) — Distinct properties |
18
- | `countSubjects()` | [`subjects.rq`](src/queries/subjects.rq) — Distinct subjects |
19
- | `countTriples()` | [`triples.rq`](src/queries/triples.rq) — Total triple count |
20
- | `detectLicenses()` | [`licenses.rq`](src/queries/licenses.rq) — License detection |
21
- | `subjectUriSpaces()` | [`subject-uri-space.rq`](src/queries/subject-uri-space.rq) — Subject URI namespaces |
22
-
23
- ### Per-class stages (iterated with a class selector):
24
-
25
- | Factory | Query |
26
- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
27
- | `perClassDatatypes()` | [`class-property-datatypes.rq`](src/queries/class-property-datatypes.rq) — Per-class datatype partitions |
28
- | `perClassLanguages()` | [`class-property-languages.rq`](src/queries/class-property-languages.rq) — Per-class language tags |
29
- | `perClassObjectClasses()` | [`class-property-object-classes.rq`](src/queries/class-property-object-classes.rq) — Per-class object class partitions |
30
-
31
- ### Domain-specific stages:
32
-
33
- | Factory | Description |
34
- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
35
- | `detectVocabularies()` | [`entity-properties.rq`](src/queries/entity-properties.rq) — Entity properties with automatic `void:vocabulary` detection |
36
- | `uriSpaces(uriSpaces)` | [`object-uri-space.rq`](src/queries/object-uri-space.rq) — Object URI namespace linksets, aggregated against a provided URI space map |
37
-
38
- All factories return `Promise<Stage>`.
39
-
40
- ## Executor decorators
9
+ Returns all VoID stages in their recommended execution order. The ordering is optimised for cache warming: `classPartitions()` runs before the per-class stages, so the `?s a ?class` pattern is already cached on the SPARQL endpoint when the heavier per-class queries execute — preventing 504 timeouts on cold caches.
41
10
 
42
- - `VocabularyExecutor` — Wraps an executor; detects known vocabulary namespace prefixes in `void:property` quads and appends `void:vocabulary` triples.
43
- - `UriSpaceExecutor` — Wraps an executor; consumes `void:Linkset` quads, matches `void:objectsTarget` against configured URI spaces, and emits aggregated linksets.
11
+ Accepts an optional `VoidStagesOptions` object:
44
12
 
45
- ## Usage
13
+ | Option | Default | Description |
14
+ | ---------------- | ------- | -------------------------------------------------- |
15
+ | `batchSize` | 10 | Maximum number of bindings per executor call |
16
+ | `maxConcurrency` | 10 | Maximum concurrent in-flight executor batches |
17
+ | `uriSpaces` | — | When provided, includes the object URI space stage |
46
18
 
47
19
  ```typescript
48
- import {
49
- countTriples,
50
- classPartitions,
51
- detectVocabularies,
52
- } from '@lde/pipeline-void';
20
+ import { voidStages } from '@lde/pipeline-void';
53
21
  import { Pipeline, SparqlUpdateWriter, provenancePlugin } from '@lde/pipeline';
54
22
 
23
+ const stages = await voidStages({ uriSpaces: uriSpaceMap });
24
+
55
25
  await new Pipeline({
56
26
  datasetSelector: selector,
57
- stages: [countTriples(), classPartitions(), detectVocabularies()],
27
+ stages,
58
28
  plugins: [provenancePlugin()],
59
29
  writers: new SparqlUpdateWriter({
60
30
  endpoint: new URL('http://localhost:7200/repositories/lde/statements'),
61
31
  }),
62
32
  }).run();
63
33
  ```
34
+
35
+ ### Individual stage factories
36
+
37
+ All factories accept an optional `VoidStageOptions` (`batchSize`, `maxConcurrency`) and return `Promise<Stage>`.
38
+
39
+ #### Global stages (one CONSTRUCT query per dataset):
40
+
41
+ | Factory | Query |
42
+ | ----------------------- | ------------------------------------------------------------------------------- |
43
+ | `classPartitions()` | [`class-partition.rq`](queries/class-partition.rq) — Classes with entity counts |
44
+ | `countDatatypes()` | [`datatypes.rq`](queries/datatypes.rq) — Dataset-level datatypes |
45
+ | `countObjectLiterals()` | [`object-literals.rq`](queries/object-literals.rq) — Literal object counts |
46
+ | `countObjectUris()` | [`object-uris.rq`](queries/object-uris.rq) — URI object counts |
47
+ | `countProperties()` | [`properties.rq`](queries/properties.rq) — Distinct properties |
48
+ | `countSubjects()` | [`subjects.rq`](queries/subjects.rq) — Distinct subjects |
49
+ | `countTriples()` | [`triples.rq`](queries/triples.rq) — Total triple count |
50
+ | `detectLicenses()` | [`licenses.rq`](queries/licenses.rq) — License detection |
51
+ | `subjectUriSpaces()` | [`subject-uri-space.rq`](queries/subject-uri-space.rq) — Subject URI namespaces |
52
+
53
+ #### Per-class stages (iterated with a class selector):
54
+
55
+ | Factory | Query |
56
+ | ------------------------- | ------------------------------------------------------------------------------------------------------------------ |
57
+ | `classPropertySubjects()` | [`class-properties-subjects.rq`](queries/class-properties-subjects.rq) — Properties per class (subject counts) |
58
+ | `classPropertyObjects()` | [`class-properties-objects.rq`](queries/class-properties-objects.rq) — Properties per class (object counts) |
59
+ | `perClassDatatypes()` | [`class-property-datatypes.rq`](queries/class-property-datatypes.rq) — Per-class datatype partitions |
60
+ | `perClassLanguages()` | [`class-property-languages.rq`](queries/class-property-languages.rq) — Per-class language tags |
61
+ | `perClassObjectClasses()` | [`class-property-object-classes.rq`](queries/class-property-object-classes.rq) — Per-class object class partitions |
62
+
63
+ #### Domain-specific stages:
64
+
65
+ | Factory | Description |
66
+ | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
67
+ | `detectVocabularies()` | [`entity-properties.rq`](queries/entity-properties.rq) — Entity properties with automatic `void:vocabulary` detection |
68
+ | `uriSpaces(uriSpaceMap)` | [`object-uri-space.rq`](queries/object-uri-space.rq) — Object URI namespace linksets, aggregated against a provided URI space map |
69
+
70
+ ## Executor decorators
71
+
72
+ - `VocabularyExecutor` — Wraps an executor; detects known vocabulary namespace prefixes in `void:property` quads and appends `void:vocabulary` triples.
73
+ - `UriSpaceExecutor` — Wraps an executor; consumes `void:Linkset` quads, matches `void:objectsTarget` against configured URI spaces, and emits aggregated linksets.
package/dist/stage.d.ts CHANGED
@@ -1,19 +1,44 @@
1
1
  import { Stage } from '@lde/pipeline';
2
2
  import type { Quad } from '@rdfjs/types';
3
- export declare function subjectUriSpaces(): Promise<Stage>;
4
- export declare function classPartitions(): Promise<Stage>;
5
- export declare function countObjectLiterals(): Promise<Stage>;
6
- export declare function countObjectUris(): Promise<Stage>;
7
- export declare function countProperties(): Promise<Stage>;
8
- export declare function countSubjects(): Promise<Stage>;
9
- export declare function countTriples(): Promise<Stage>;
10
- export declare function classPropertySubjects(): Promise<Stage>;
11
- export declare function classPropertyObjects(): Promise<Stage>;
12
- export declare function countDatatypes(): Promise<Stage>;
13
- export declare function detectLicenses(): Promise<Stage>;
14
- export declare function perClassObjectClasses(): Promise<Stage>;
15
- export declare function perClassDatatypes(): Promise<Stage>;
16
- export declare function perClassLanguages(): Promise<Stage>;
17
- export declare function uriSpaces(uriSpaces: ReadonlyMap<string, readonly Quad[]>): Promise<Stage>;
18
- export declare function detectVocabularies(): Promise<Stage>;
3
+ /**
4
+ * Options for configuring VoID stage execution.
5
+ */
6
+ export interface VoidStageOptions {
7
+ /** Maximum number of bindings per executor call. @default 10 */
8
+ batchSize?: number;
9
+ /** Maximum concurrent in-flight executor batches. @default 10 */
10
+ maxConcurrency?: number;
11
+ }
12
+ /**
13
+ * Options for the {@link voidStages} convenience function.
14
+ */
15
+ export interface VoidStagesOptions extends VoidStageOptions {
16
+ /** When provided, includes the object URI space stage using this map. */
17
+ uriSpaces?: ReadonlyMap<string, readonly Quad[]>;
18
+ }
19
+ export declare function subjectUriSpaces(options?: VoidStageOptions): Promise<Stage>;
20
+ export declare function classPartitions(options?: VoidStageOptions): Promise<Stage>;
21
+ export declare function countObjectLiterals(options?: VoidStageOptions): Promise<Stage>;
22
+ export declare function countObjectUris(options?: VoidStageOptions): Promise<Stage>;
23
+ export declare function countProperties(options?: VoidStageOptions): Promise<Stage>;
24
+ export declare function countSubjects(options?: VoidStageOptions): Promise<Stage>;
25
+ export declare function countTriples(options?: VoidStageOptions): Promise<Stage>;
26
+ export declare function classPropertySubjects(options?: VoidStageOptions): Promise<Stage>;
27
+ export declare function classPropertyObjects(options?: VoidStageOptions): Promise<Stage>;
28
+ export declare function countDatatypes(options?: VoidStageOptions): Promise<Stage>;
29
+ export declare function detectLicenses(options?: VoidStageOptions): Promise<Stage>;
30
+ export declare function perClassObjectClasses(options?: VoidStageOptions): Promise<Stage>;
31
+ export declare function perClassDatatypes(options?: VoidStageOptions): Promise<Stage>;
32
+ export declare function perClassLanguages(options?: VoidStageOptions): Promise<Stage>;
33
+ export declare function uriSpaces(uriSpaceMap: ReadonlyMap<string, readonly Quad[]>, options?: VoidStageOptions): Promise<Stage>;
34
+ export declare function detectVocabularies(options?: VoidStageOptions): Promise<Stage>;
35
+ /**
36
+ * Create all VoID analysis stages in their recommended execution order.
37
+ *
38
+ * The stages are ordered so that {@link classPartitions} runs before the
39
+ * per-class stages. This warms up the `?s a ?class` pattern cache on the
40
+ * SPARQL endpoint, preventing 504 timeouts on the heavier per-class queries
41
+ * when the cache is cold.
42
+ */
43
+ export declare function voidStages(options?: VoidStagesOptions): Promise<Stage[]>;
19
44
  //# sourceMappingURL=stage.d.ts.map
package/dist/stage.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAMN,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAyDzC,wBAAgB,gBAAgB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEjD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAAC,KAAK,CAAC,CAEhD;AAED,wBAAgB,mBAAmB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEpD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAAC,KAAK,CAAC,CAEhD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAAC,KAAK,CAAC,CAEhD;AAED,wBAAgB,aAAa,IAAI,OAAO,CAAC,KAAK,CAAC,CAE9C;AAED,wBAAgB,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC,CAE7C;AAED,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,CAEtD;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,KAAK,CAAC,CAErD;AAED,wBAAgB,cAAc,IAAI,OAAO,CAAC,KAAK,CAAC,CAE/C;AAED,wBAAgB,cAAc,IAAI,OAAO,CAAC,KAAK,CAAC,CAE/C;AAID,wBAAgB,qBAAqB,IAAI,OAAO,CAAC,KAAK,CAAC,CAItD;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,KAAK,CAAC,CAIlD;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,KAAK,CAAC,CAIlD;AAID,wBAAgB,SAAS,CACvB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,GAC9C,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,KAAK,CAAC,CAKnD"}
1
+ {"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../src/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAMN,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAYzC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACzD,yEAAyE;IACzE,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;CAClD;AAwDD,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE3E;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE1E;AAED,wBAAgB,mBAAmB,CACjC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAEhB;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE1E;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAE1E;AAED,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAExE;AAED,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAEvE;AAED,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAEzE;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAEzE;AAID,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAKhB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAK5E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAK5E;AAID,wBAAgB,SAAS,CACvB,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,EACjD,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAAC,CAMhB;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,KAAK,CAAC,CAM7E;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,KAAK,EAAE,CAAC,CA4BlB"}
package/dist/stage.js CHANGED
@@ -12,9 +12,16 @@ async function createVoidStage(filename, options) {
12
12
  name: filename,
13
13
  itemSelector: classSelector(),
14
14
  executors: executor,
15
+ batchSize: options?.batchSize,
16
+ maxConcurrency: options?.maxConcurrency,
15
17
  });
16
18
  }
17
- return new Stage({ name: filename, executors: executor });
19
+ return new Stage({
20
+ name: filename,
21
+ executors: executor,
22
+ batchSize: options?.batchSize,
23
+ maxConcurrency: options?.maxConcurrency,
24
+ });
18
25
  }
19
26
  function classSelector() {
20
27
  return {
@@ -37,63 +44,107 @@ function classSelector() {
37
44
  };
38
45
  }
39
46
  // Global stages
40
- export function subjectUriSpaces() {
41
- return createVoidStage('subject-uri-space.rq');
47
+ export function subjectUriSpaces(options) {
48
+ return createVoidStage('subject-uri-space.rq', options);
42
49
  }
43
- export function classPartitions() {
44
- return createVoidStage('class-partition.rq');
50
+ export function classPartitions(options) {
51
+ return createVoidStage('class-partition.rq', options);
45
52
  }
46
- export function countObjectLiterals() {
47
- return createVoidStage('object-literals.rq');
53
+ export function countObjectLiterals(options) {
54
+ return createVoidStage('object-literals.rq', options);
48
55
  }
49
- export function countObjectUris() {
50
- return createVoidStage('object-uris.rq');
56
+ export function countObjectUris(options) {
57
+ return createVoidStage('object-uris.rq', options);
51
58
  }
52
- export function countProperties() {
53
- return createVoidStage('properties.rq');
59
+ export function countProperties(options) {
60
+ return createVoidStage('properties.rq', options);
54
61
  }
55
- export function countSubjects() {
56
- return createVoidStage('subjects.rq');
62
+ export function countSubjects(options) {
63
+ return createVoidStage('subjects.rq', options);
57
64
  }
58
- export function countTriples() {
59
- return createVoidStage('triples.rq');
65
+ export function countTriples(options) {
66
+ return createVoidStage('triples.rq', options);
60
67
  }
61
- export function classPropertySubjects() {
62
- return createVoidStage('class-properties-subjects.rq');
68
+ export function classPropertySubjects(options) {
69
+ return createVoidStage('class-properties-subjects.rq', {
70
+ ...options,
71
+ selection: 'perClass',
72
+ });
63
73
  }
64
- export function classPropertyObjects() {
65
- return createVoidStage('class-properties-objects.rq');
74
+ export function classPropertyObjects(options) {
75
+ return createVoidStage('class-properties-objects.rq', {
76
+ ...options,
77
+ selection: 'perClass',
78
+ });
66
79
  }
67
- export function countDatatypes() {
68
- return createVoidStage('datatypes.rq');
80
+ export function countDatatypes(options) {
81
+ return createVoidStage('datatypes.rq', options);
69
82
  }
70
- export function detectLicenses() {
71
- return createVoidStage('licenses.rq');
83
+ export function detectLicenses(options) {
84
+ return createVoidStage('licenses.rq', options);
72
85
  }
73
86
  // Per-class stages
74
- export function perClassObjectClasses() {
87
+ export function perClassObjectClasses(options) {
75
88
  return createVoidStage('class-property-object-classes.rq', {
89
+ ...options,
76
90
  selection: 'perClass',
77
91
  });
78
92
  }
79
- export function perClassDatatypes() {
93
+ export function perClassDatatypes(options) {
80
94
  return createVoidStage('class-property-datatypes.rq', {
95
+ ...options,
81
96
  selection: 'perClass',
82
97
  });
83
98
  }
84
- export function perClassLanguages() {
99
+ export function perClassLanguages(options) {
85
100
  return createVoidStage('class-property-languages.rq', {
101
+ ...options,
86
102
  selection: 'perClass',
87
103
  });
88
104
  }
89
105
  // Domain-specific executor stages
90
- export function uriSpaces(uriSpaces) {
106
+ export function uriSpaces(uriSpaceMap, options) {
91
107
  return createVoidStage('object-uri-space.rq', {
92
- executor: (query) => new UriSpaceExecutor(new SparqlConstructExecutor({ query }), uriSpaces),
108
+ ...options,
109
+ executor: (query) => new UriSpaceExecutor(new SparqlConstructExecutor({ query }), uriSpaceMap),
93
110
  });
94
111
  }
95
- export function detectVocabularies() {
112
+ export function detectVocabularies(options) {
96
113
  return createVoidStage('entity-properties.rq', {
114
+ ...options,
97
115
  executor: (query) => new VocabularyExecutor(new SparqlConstructExecutor({ query })),
98
116
  });
99
117
  }
118
+ /**
119
+ * Create all VoID analysis stages in their recommended execution order.
120
+ *
121
+ * The stages are ordered so that {@link classPartitions} runs before the
122
+ * per-class stages. This warms up the `?s a ?class` pattern cache on the
123
+ * SPARQL endpoint, preventing 504 timeouts on the heavier per-class queries
124
+ * when the cache is cold.
125
+ */
126
+ export async function voidStages(options) {
127
+ const { uriSpaces: uriSpaceMap, ...stageOptions } = options ?? {};
128
+ return Promise.all([
129
+ // Global counting stages.
130
+ countSubjects(stageOptions),
131
+ countProperties(stageOptions),
132
+ countObjectLiterals(stageOptions),
133
+ countObjectUris(stageOptions),
134
+ countDatatypes(stageOptions),
135
+ countTriples(stageOptions),
136
+ // Cache warming — must precede per-class stages.
137
+ classPartitions(stageOptions),
138
+ // Per-class stages.
139
+ classPropertySubjects(stageOptions),
140
+ classPropertyObjects(stageOptions),
141
+ perClassDatatypes(stageOptions),
142
+ perClassObjectClasses(stageOptions),
143
+ perClassLanguages(stageOptions),
144
+ // Other stages.
145
+ detectLicenses(stageOptions),
146
+ detectVocabularies(stageOptions),
147
+ subjectUriSpaces(stageOptions),
148
+ ...(uriSpaceMap ? [uriSpaces(uriSpaceMap, stageOptions)] : []),
149
+ ]);
150
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@lde/pipeline-void",
3
- "version": "0.19.1",
3
+ "version": "0.20.0",
4
4
  "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
5
5
  "repository": {
6
6
  "url": "git+https://github.com/ldelements/lde.git",
@@ -32,6 +32,6 @@
32
32
  },
33
33
  "peerDependencies": {
34
34
  "@lde/dataset": "0.7.1",
35
- "@lde/pipeline": "0.22.1"
35
+ "@lde/pipeline": "0.23.0"
36
36
  }
37
37
  }
package/queries/class-properties-objects.rq CHANGED
@@ -6,12 +6,16 @@ CONSTRUCT {
6
6
  WHERE {
7
7
  # Object counts only. Subject counts in class-properties-subjects.rq.
8
8
  {
9
- SELECT ?type ?p (COUNT(DISTINCT ?o) AS ?objects) {
10
- #subjectFilter#
11
- ?s a ?type ; ?p ?o .
9
+ SELECT ?class ?p (COUNT(DISTINCT ?o) AS ?objects) {
10
+ {
11
+ SELECT ?class ?p ?o {
12
+ #subjectFilter#
13
+ ?s a ?class ; ?p ?o .
14
+ }
15
+ }
12
16
  }
13
- GROUP BY ?type ?p
17
+ GROUP BY ?class ?p
14
18
  }
15
- BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?type), STR(?p))))) AS ?propertyPartition)
19
+ BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
16
20
  }
17
21
  LIMIT 100000
package/queries/class-properties-subjects.rq CHANGED
@@ -3,7 +3,7 @@ PREFIX void: <http://rdfs.org/ns/void#>
3
3
  CONSTRUCT {
4
4
  ?dataset a void:Dataset ;
5
5
  void:classPartition ?classPartition .
6
- ?classPartition void:class ?type ;
6
+ ?classPartition void:class ?class ;
7
7
  void:propertyPartition ?propertyPartition .
8
8
  ?propertyPartition void:property ?p ;
9
9
  void:entities ?subjects .
@@ -11,13 +11,17 @@ CONSTRUCT {
11
11
  WHERE {
12
12
  # Subject counts only. Object counts in class-properties-objects.rq.
13
13
  {
14
- SELECT ?type ?p (COUNT(DISTINCT ?s) AS ?subjects) {
15
- #subjectFilter#
16
- ?s a ?type ; ?p [] .
14
+ SELECT ?class ?p (COUNT(DISTINCT ?s) AS ?subjects) {
15
+ {
16
+ SELECT ?class ?p ?s {
17
+ #subjectFilter#
18
+ ?s a ?class ; ?p [] .
19
+ }
20
+ }
17
21
  }
18
- GROUP BY ?type ?p
22
+ GROUP BY ?class ?p
19
23
  }
20
- BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?type)))) AS ?classPartition)
21
- BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?type), STR(?p))))) AS ?propertyPartition)
24
+ BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-", MD5(STR(?class)))) AS ?classPartition)
25
+ BIND(URI(CONCAT(STR(?dataset), "/.well-known/void#class-property-", MD5(CONCAT(STR(?class), STR(?p))))) AS ?propertyPartition)
22
26
  }
23
27
  LIMIT 100000