@comunica/actor-rdf-join-selectivity-variable-counting 2.0.1-alpha.5.0

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2017–now Ruben Taelman, Joachim Van Herwegen
+Comunica Association and Ghent University – imec, Belgium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# Comunica Variable Counting RDF Join Selectivity Actor
+
+[![npm version](https://badge.fury.io/js/%40comunica%2Factor-rdf-join-selectivity-variable-counting.svg)](https://www.npmjs.com/package/@comunica/actor-rdf-join-selectivity-variable-counting)
+
+An [RDF Join Selectivity](https://github.com/comunica/comunica/tree/master/packages/bus-rdf-join-selectivity) actor
+that heuristically tries to estimate the selectivity of joins by counting the overlap of variables and non-variables
+in patterns. 
+
+Based on the _"variable counting predicates"_ heuristic from
+[_Stocker, Markus, et al. "SPARQL basic graph pattern optimization using selectivity estimation." Proceedings of the 17th international conference on World Wide Web. 2008._](https://www.semanticscholar.org/paper/SPARQL-basic-graph-pattern-optimization-using-Stocker-Seaborne/da4d7bf764d918f6dfb2b285dfc3e12da7b62b00).
+Implementation inspired by http://www.docjar.com/docs/api/com/hp/hpl/jena/sparql/engine/optimizer/heuristic/VariableCountingUnbound.html.
+This algorithm is extended to also support non-triple-pattern operations and quads.
+
+This module is part of the [Comunica framework](https://github.com/comunica/comunica),
+and should only be used by [developers that want to build their own query engine](https://comunica.dev/docs/modify/).
+
+[Click here if you just want to query with Comunica](https://comunica.dev/docs/query/).
+
+## Install
+
+```bash
+$ yarn add @comunica/actor-rdf-join-selectivity-variable-counting
+```
+
+## Configure
+
+After installing, this package can be added to your engine's configuration as follows:
+```text
+{
+  "@context": [
+    ...
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/actor-rdf-join-selectivity-variable-counting/^2.0.0/components/context.jsonld"  
+  ],
+  "actors": [
+    ...
+    {
+      "@id": "config-sets:join.json#myRdfJoinSelectivityActorVariableCounting",
+      "@type": "ActorRdfJoinSelectivityVariableCounting"
+    }
+  ]
+}
+```

package/components/ActorRdfJoinSelectivityVariableCounting.jsonld

@@ -0,0 +1,166 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/actor-rdf-join-selectivity-variable-counting/^2.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/bus-rdf-join-selectivity/^2.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/core/^2.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/actor-rdf-join-selectivity-variable-counting",
+  "components": [
+    {
+      "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting",
+      "@type": "Class",
+      "requireElement": "ActorRdfJoinSelectivityVariableCounting",
+      "extends": [
+        "cbrjs:components/ActorRdfJoinSelectivity.jsonld#ActorRdfJoinSelectivity"
+      ],
+      "comment": "A comunica Variable Counting RDF Join Selectivity Actor. Based on the \"variable counting predicates\" heuristic from \"SPARQL basic graph pattern optimization using selectivity estimation.\"",
+      "parameters": [
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_name",
+          "range": "xsd:string",
+          "default": {
+            "@id": "rdf:subject"
+          },
+          "comment": "The name for this actor."
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_bus",
+          "range": {
+            "@type": "ParameterRangeGenericComponent",
+            "component": "cc:components/Bus.jsonld#Bus",
+            "genericTypeInstances": [
+              {
+                "@type": "ParameterRangeGenericComponent",
+                "component": "cc:components/Actor.jsonld#Actor",
+                "genericTypeInstances": [
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                  },
+                  {
+                    "@type": "ParameterRangeGenericTypeReference",
+                    "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                  }
+                ]
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+              },
+              {
+                "@type": "ParameterRangeGenericTypeReference",
+                "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+              }
+            ]
+          },
+          "default": {
+            "@id": "cbrjs:components/ActorRdfJoinSelectivity.jsonld#ActorRdfJoinSelectivity_default_bus",
+            "@type": "cc:components/Bus.jsonld#Bus"
+          },
+          "comment": "The bus this actor subscribes to."
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_beforeActors",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              {
+                "@type": "ParameterRangeArray",
+                "parameterRangeValue": {
+                  "@type": "ParameterRangeGenericComponent",
+                  "component": "cc:components/Actor.jsonld#Actor",
+                  "genericTypeInstances": [
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_I"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_T"
+                    },
+                    {
+                      "@type": "ParameterRangeGenericTypeReference",
+                      "parameterRangeGenericType": "npmd:@comunica/actor-abstract-mediatyped/^2.0.0/components/ActorAbstractMediaTyped.jsonld#ActorAbstractMediaTyped__generic_O"
+                    }
+                  ]
+                }
+              },
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "Actor that must be registered in the bus before this actor."
+        }
+      ],
+      "memberFields": [
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_MAX_PAIRWISE_COST",
+          "memberFieldName": "MAX_PAIRWISE_COST",
+          "range": "xsd:number"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_constructor",
+          "memberFieldName": "constructor"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_test",
+          "memberFieldName": "test"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_getPatternCost",
+          "memberFieldName": "getPatternCost"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_getJoinTypes",
+          "memberFieldName": "getJoinTypes"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_getOperationsPairwiseJoinCost",
+          "memberFieldName": "getOperationsPairwiseJoinCost"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_getOperationsJoinCost",
+          "memberFieldName": "getOperationsJoinCost"
+        },
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting__member_run",
+          "memberFieldName": "run"
+        }
+      ],
+      "constructorArguments": [
+        {
+          "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "name",
+              "value": {
+                "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_name"
+              }
+            },
+            {
+              "keyRaw": "bus",
+              "value": {
+                "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_bus"
+              }
+            },
+            {
+              "keyRaw": "beforeActors",
+              "value": {
+                "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_beforeActors"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/components/components.jsonld

@@ -0,0 +1,11 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@comunica/actor-rdf-join-selectivity-variable-counting/^2.0.0/components/context.jsonld"
+  ],
+  "@id": "npmd:@comunica/actor-rdf-join-selectivity-variable-counting",
+  "@type": "Module",
+  "requireName": "@comunica/actor-rdf-join-selectivity-variable-counting",
+  "import": [
+    "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld"
+  ]
+}

package/components/context.jsonld

@@ -0,0 +1,35 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^4.0.0/components/context.jsonld",
+    {
+      "npmd": "https://linkedsoftwaredependencies.org/bundles/npm/",
+      "carjsvc": "npmd:@comunica/actor-rdf-join-selectivity-variable-counting/^2.0.0/",
+      "ActorRdfJoinSelectivityVariableCounting": {
+        "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting",
+        "@prefix": true,
+        "@context": {
+          "args_name": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_name"
+          },
+          "args_bus": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_bus"
+          },
+          "args_beforeActors": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_beforeActors",
+            "@container": "@list"
+          },
+          "name": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_name"
+          },
+          "bus": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_bus"
+          },
+          "beforeActors": {
+            "@id": "carjsvc:components/ActorRdfJoinSelectivityVariableCounting.jsonld#ActorRdfJoinSelectivityVariableCounting_args_beforeActors",
+            "@container": "@list"
+          }
+        }
+      }
+    }
+  ]
+}

package/lib/ActorRdfJoinSelectivityVariableCounting.d.ts

@@ -0,0 +1,54 @@
+import type { IActionRdfJoinSelectivity, IActorRdfJoinSelectivityOutput } from '@comunica/bus-rdf-join-selectivity';
+import { ActorRdfJoinSelectivity } from '@comunica/bus-rdf-join-selectivity';
+import type { IActorArgs } from '@comunica/core';
+import type { IMediatorTypeAccuracy } from '@comunica/mediatortype-accuracy';
+import { Algebra } from 'sparqlalgebrajs';
+/**
+ * A comunica Variable Counting RDF Join Selectivity Actor.
+ * Based on the "variable counting predicates" heuristic from
+ * "SPARQL basic graph pattern optimization using selectivity estimation."
+ */
+export declare class ActorRdfJoinSelectivityVariableCounting extends ActorRdfJoinSelectivity {
+    static MAX_PAIRWISE_COST: number;
+    constructor(args: IActorArgs<IActionRdfJoinSelectivity, IMediatorTypeAccuracy, IActorRdfJoinSelectivityOutput>);
+    test(action: IActionRdfJoinSelectivity): Promise<IMediatorTypeAccuracy>;
+    static getPatternCost(pattern: Algebra.Pattern | Algebra.Path): number;
+    static getJoinTypes(operation1: Algebra.Pattern | Algebra.Path, operation2: Algebra.Pattern | Algebra.Path): JoinTypes[];
+    static getOperationsPairwiseJoinCost(operation1: Algebra.Pattern | Algebra.Path, operation2: Algebra.Pattern | Algebra.Path): number;
+    static getOperationsJoinCost(operations: Algebra.Operation[]): number;
+    run(action: IActionRdfJoinSelectivity): Promise<IActorRdfJoinSelectivityOutput>;
+}
+export declare enum JoinTypes {
+    boundSS = 0,
+    boundSP = 1,
+    boundSO = 2,
+    boundSG = 3,
+    boundPS = 4,
+    boundPP = 5,
+    boundPO = 6,
+    boundPG = 7,
+    boundOS = 8,
+    boundOP = 9,
+    boundOO = 10,
+    boundOG = 11,
+    boundGS = 12,
+    boundGP = 13,
+    boundGO = 14,
+    boundGG = 15,
+    unboundSS = 16,
+    unboundSP = 17,
+    unboundSO = 18,
+    unboundSG = 19,
+    unboundPS = 20,
+    unboundPP = 21,
+    unboundPO = 22,
+    unboundPG = 23,
+    unboundOS = 24,
+    unboundOP = 25,
+    unboundOO = 26,
+    unboundOG = 27,
+    unboundGS = 28,
+    unboundGP = 29,
+    unboundGO = 30,
+    unboundGG = 31
+}

package/lib/ActorRdfJoinSelectivityVariableCounting.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinTypes = exports.ActorRdfJoinSelectivityVariableCounting = void 0;
+const bus_rdf_join_selectivity_1 = require("@comunica/bus-rdf-join-selectivity");
+const sparqlalgebrajs_1 = require("sparqlalgebrajs");
+/**
+ * A comunica Variable Counting RDF Join Selectivity Actor.
+ * Based on the "variable counting predicates" heuristic from
+ * "SPARQL basic graph pattern optimization using selectivity estimation."
+ */
+class ActorRdfJoinSelectivityVariableCounting extends bus_rdf_join_selectivity_1.ActorRdfJoinSelectivity {
+    constructor(args) {
+        super(args);
+    }
+    async test(action) {
+        return { accuracy: 0.5 };
+    }
+    static getPatternCost(pattern) {
+        let cost = 1;
+        if (pattern.subject.termType === 'Variable') {
+            cost += 4;
+        }
+        if (pattern.predicate.termType === 'Variable' || pattern.type === sparqlalgebrajs_1.Algebra.types.PATH) {
+            cost += 1;
+        }
+        if (pattern.object.termType === 'Variable') {
+            cost += 2;
+        }
+        if (pattern.graph.termType === 'Variable') {
+            cost += 1;
+        }
+        return cost / 9;
+    }
+    static getJoinTypes(operation1, operation2) {
+        const joinTypes = [];
+        // Check operation1.subject
+        if (operation1.subject.termType === 'Variable') {
+            if (operation1.subject.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.unboundSS);
+            }
+            if (operation2.type === 'pattern' && operation1.subject.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.unboundSP);
+            }
+            if (operation1.subject.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.unboundSO);
+            }
+            if (operation1.subject.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.unboundSG);
+            }
+        }
+        else {
+            if (operation1.subject.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.boundSS);
+            }
+            if (operation2.type === 'pattern' && operation1.subject.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.boundSP);
+            }
+            if (operation1.subject.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.boundSO);
+            }
+            if (operation1.subject.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.boundSG);
+            }
+        }
+        // Check operation1.predicate
+        if (operation1.type === 'pattern') {
+            if (operation1.predicate.termType === 'Variable') {
+                if (operation1.predicate.equals(operation2.subject)) {
+                    joinTypes.push(JoinTypes.unboundPS);
+                }
+                if (operation2.type === 'pattern' && operation1.predicate.equals(operation2.predicate)) {
+                    joinTypes.push(JoinTypes.unboundPP);
+                }
+                if (operation1.predicate.equals(operation2.object)) {
+                    joinTypes.push(JoinTypes.unboundPO);
+                }
+                if (operation1.predicate.equals(operation2.graph)) {
+                    joinTypes.push(JoinTypes.unboundPG);
+                }
+            }
+            else {
+                if (operation1.predicate.equals(operation2.subject)) {
+                    joinTypes.push(JoinTypes.boundPS);
+                }
+                if (operation2.type === 'pattern' && operation1.predicate.equals(operation2.predicate)) {
+                    joinTypes.push(JoinTypes.boundPP);
+                }
+                if (operation1.predicate.equals(operation2.object)) {
+                    joinTypes.push(JoinTypes.boundPO);
+                }
+                if (operation1.predicate.equals(operation2.graph)) {
+                    joinTypes.push(JoinTypes.boundPG);
+                }
+            }
+        }
+        // Check operation1.object
+        if (operation1.object.termType === 'Variable') {
+            if (operation1.object.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.unboundOS);
+            }
+            if (operation2.type === 'pattern' && operation1.object.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.unboundOP);
+            }
+            if (operation1.object.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.unboundOO);
+            }
+            if (operation1.object.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.unboundOG);
+            }
+        }
+        else {
+            if (operation1.object.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.boundOS);
+            }
+            if (operation2.type === 'pattern' && operation1.object.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.boundOP);
+            }
+            if (operation1.object.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.boundOO);
+            }
+            if (operation1.object.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.boundOG);
+            }
+        }
+        // Check operation1.graph
+        if (operation1.graph.termType === 'Variable') {
+            if (operation1.graph.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.unboundGS);
+            }
+            if (operation2.type === 'pattern' && operation1.graph.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.unboundGP);
+            }
+            if (operation1.graph.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.unboundGO);
+            }
+            if (operation1.graph.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.unboundGG);
+            }
+        }
+        else {
+            if (operation1.graph.equals(operation2.subject)) {
+                joinTypes.push(JoinTypes.boundGS);
+            }
+            if (operation2.type === 'pattern' && operation1.graph.equals(operation2.predicate)) {
+                joinTypes.push(JoinTypes.boundGP);
+            }
+            if (operation1.graph.equals(operation2.object)) {
+                joinTypes.push(JoinTypes.boundGO);
+            }
+            if (operation1.graph.equals(operation2.graph)) {
+                joinTypes.push(JoinTypes.boundGG);
+            }
+        }
+        return joinTypes;
+    }
+    static getOperationsPairwiseJoinCost(operation1, operation2) {
+        let cost = ActorRdfJoinSelectivityVariableCounting.MAX_PAIRWISE_COST;
+        for (const joinType of ActorRdfJoinSelectivityVariableCounting.getJoinTypes(operation1, operation2)) {
+            switch (joinType) {
+                case JoinTypes.boundSS:
+                    cost -= 2 * 2;
+                    break;
+                case JoinTypes.boundSP:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundSO:
+                    cost -= 1 * 2;
+                    break;
+                case JoinTypes.boundSG:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundPS:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundPP:
+                    // Special case: patterns with equal (bound) predicates have the highest cost
+                    return 1;
+                case JoinTypes.boundPO:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundPG:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundOS:
+                    cost -= 1 * 2;
+                    break;
+                case JoinTypes.boundOP:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundOO:
+                    cost -= 1 * 2;
+                    break;
+                case JoinTypes.boundOG:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundGS:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundGP:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundGO:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.boundGG:
+                    cost -= 3 * 2;
+                    break;
+                case JoinTypes.unboundSS:
+                    cost -= 2;
+                    break;
+                case JoinTypes.unboundSP:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundSO:
+                    cost -= 1;
+                    break;
+                case JoinTypes.unboundSG:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundPS:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundPP:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundPO:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundPG:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundOS:
+                    cost -= 1;
+                    break;
+                case JoinTypes.unboundOP:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundOO:
+                    cost -= 1;
+                    break;
+                case JoinTypes.unboundOG:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundGS:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundGP:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundGO:
+                    cost -= 3;
+                    break;
+                case JoinTypes.unboundGG:
+                    cost -= 3;
+                    break;
+            }
+        }
+        return cost / ActorRdfJoinSelectivityVariableCounting.MAX_PAIRWISE_COST;
+    }
+    static getOperationsJoinCost(operations) {
+        // Determine all operations that select values (patterns and paths)
+        const patterns = [];
+        for (const operation of operations) {
+            sparqlalgebrajs_1.Util.recurseOperation(operation, {
+                [sparqlalgebrajs_1.Algebra.types.PATTERN](pattern) {
+                    patterns.push(pattern);
+                    return false;
+                },
+                [sparqlalgebrajs_1.Algebra.types.PATH](path) {
+                    patterns.push(path);
+                    return false;
+                },
+            });
+        }
+        // Determine pairwise costs
+        let totalCost = 0;
+        let costEntries = 0;
+        for (const pattern1 of patterns) {
+            for (const pattern2 of patterns) {
+                if (pattern1 !== pattern2) {
+                    totalCost += ActorRdfJoinSelectivityVariableCounting.getOperationsPairwiseJoinCost(pattern1, pattern2);
+                    costEntries++;
+                }
+            }
+        }
+        // Combine all pairwise costs, and multiply with costs of each pattern separately
+        return totalCost / costEntries * patterns
+            .reduce((factor, pattern) => factor * ActorRdfJoinSelectivityVariableCounting.getPatternCost(pattern), 1);
+    }
+    async run(action) {
+        if (action.entries.length <= 1) {
+            return { selectivity: 1 };
+        }
+        return {
+            selectivity: ActorRdfJoinSelectivityVariableCounting
+                .getOperationsJoinCost(action.entries.map(entry => entry.operation)),
+        };
+    }
+}
+exports.ActorRdfJoinSelectivityVariableCounting = ActorRdfJoinSelectivityVariableCounting;
+// Calculated as sum of unbound join type costs times 2 (best-case)
+ActorRdfJoinSelectivityVariableCounting.MAX_PAIRWISE_COST = 41 * 2;
+var JoinTypes;
+(function (JoinTypes) {
+    JoinTypes[JoinTypes["boundSS"] = 0] = "boundSS";
+    JoinTypes[JoinTypes["boundSP"] = 1] = "boundSP";
+    JoinTypes[JoinTypes["boundSO"] = 2] = "boundSO";
+    JoinTypes[JoinTypes["boundSG"] = 3] = "boundSG";
+    JoinTypes[JoinTypes["boundPS"] = 4] = "boundPS";
+    JoinTypes[JoinTypes["boundPP"] = 5] = "boundPP";
+    JoinTypes[JoinTypes["boundPO"] = 6] = "boundPO";
+    JoinTypes[JoinTypes["boundPG"] = 7] = "boundPG";
+    JoinTypes[JoinTypes["boundOS"] = 8] = "boundOS";
+    JoinTypes[JoinTypes["boundOP"] = 9] = "boundOP";
+    JoinTypes[JoinTypes["boundOO"] = 10] = "boundOO";
+    JoinTypes[JoinTypes["boundOG"] = 11] = "boundOG";
+    JoinTypes[JoinTypes["boundGS"] = 12] = "boundGS";
+    JoinTypes[JoinTypes["boundGP"] = 13] = "boundGP";
+    JoinTypes[JoinTypes["boundGO"] = 14] = "boundGO";
+    JoinTypes[JoinTypes["boundGG"] = 15] = "boundGG";
+    JoinTypes[JoinTypes["unboundSS"] = 16] = "unboundSS";
+    JoinTypes[JoinTypes["unboundSP"] = 17] = "unboundSP";
+    JoinTypes[JoinTypes["unboundSO"] = 18] = "unboundSO";
+    JoinTypes[JoinTypes["unboundSG"] = 19] = "unboundSG";
+    JoinTypes[JoinTypes["unboundPS"] = 20] = "unboundPS";
+    JoinTypes[JoinTypes["unboundPP"] = 21] = "unboundPP";
+    JoinTypes[JoinTypes["unboundPO"] = 22] = "unboundPO";
+    JoinTypes[JoinTypes["unboundPG"] = 23] = "unboundPG";
+    JoinTypes[JoinTypes["unboundOS"] = 24] = "unboundOS";
+    JoinTypes[JoinTypes["unboundOP"] = 25] = "unboundOP";
+    JoinTypes[JoinTypes["unboundOO"] = 26] = "unboundOO";
+    JoinTypes[JoinTypes["unboundOG"] = 27] = "unboundOG";
+    JoinTypes[JoinTypes["unboundGS"] = 28] = "unboundGS";
+    JoinTypes[JoinTypes["unboundGP"] = 29] = "unboundGP";
+    JoinTypes[JoinTypes["unboundGO"] = 30] = "unboundGO";
+    JoinTypes[JoinTypes["unboundGG"] = 31] = "unboundGG";
+})(JoinTypes = exports.JoinTypes || (exports.JoinTypes = {}));
+//# sourceMappingURL=ActorRdfJoinSelectivityVariableCounting.js.map

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './ActorRdfJoinSelectivityVariableCounting';

package/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ActorRdfJoinSelectivityVariableCounting"), exports);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@comunica/actor-rdf-join-selectivity-variable-counting",
+  "version": "2.0.1-alpha.5.0",
+  "description": "A variable-counting rdf-join-selectivity actor",
+  "lsd:module": true,
+  "main": "lib/index.js",
+  "typings": "lib/index",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/comunica/comunica.git",
+    "directory": "packages/actor-rdf-join-selectivity-variable-counting"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "comunica",
+    "actor",
+    "rdf-join-selectivity",
+    "variable-counting"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/comunica/comunica/issues"
+  },
+  "homepage": "https://comunica.dev/",
+  "files": [
+    "components",
+    "lib/**/*.d.ts",
+    "lib/**/*.js"
+  ],
+  "dependencies": {
+    "@comunica/bus-rdf-join-selectivity": "2.0.1-alpha.5.0",
+    "@comunica/core": "2.0.1-alpha.5.0",
+    "sparqlalgebrajs": "^4.0.0"
+  },
+  "scripts": {
+    "build": "npm run build:ts && npm run build:components",
+    "build:ts": "node \"../../node_modules/typescript/bin/tsc\"",
+    "build:components": "componentsjs-generator"
+  },
+  "gitHead": "e2ae2e9e924bf0656df60cc99774f7e560d47695"
+}