jdbc:sap://<hostname>/?databaseName=<database>&instanceNumber=<instance number>&currentSchema=<schema>
jdbc:databricks://<instance hostname>:443;HttpPath=<Http Path>
jdbc:salesforce://<instance hostname>;Endpoint=https://<instance hostname>/services/Soap/u/46.0
jdbc:spark://<instance hostname>:10000/<database>
jdbc:splunk:user=<username>;password=<password>;Url=<Your Url>
jdbc:awsathena://<AWS hostname>:443;S3OutputLocation=s3://<bucket name>/<bucket path>;Schema=<schema name>
Specifies coalesce strategy for service queries: union: only push union and unary operators into service queries join: only push join and unary operators into service queries default: push union, join, and unary operators into service queries off: don't push any operator into service queries
Specifies how the optimizer should try to patterns under reasoning operators like '?s rdf:type ?type': aggressive: always push the one which looks the most selective default: the optimizer will decide based on any available criteria off: the optimization is off
Specifies whether query rewriting is on or off for this group graph pattern
If On, the query engine will try to postpone dictionary encoding for nodes generatedduring query evaluation until necessary, for example, till a join condition requires it for evaluation.
Specifies how many SPARQL SERVICE results will be parsed from the response before processing
Strategy to select join algorithms during optimization standard: the join order optimizer will decide. economic: the join order optimizer should try to avoid joins with large memory footprints. aggressive: the join order optimizer should select the fastest joins pretending there won't be memory issues. streaming: the join order optimizer should avoid pipeline breaking operations.
In the presence of Services in a query, generate top k plan and choose most robust plan.
Specifies how query rewriting should be done: per_scope: all triple patterns as a group (default) per_pattern: each triple pattern individually (results in smaller rewritings in some cases)
Enables the optimizer to decompose query patterns in order to prevent non-selective joins before main optimization phase: aggressive: always prefer to prevent non-selective joins default: let the optimizer decide based on join selectivity off: don't decompose group graph patterns along non-selective joins
Cache target details for VG cache creation process using external compute
Specifies the limit of the number of graphs in FROM and FROM NAMED which could be inlined in the query string using UNION
Enables grouping of graph patterns for join order optimization: all patterns in the group will be joined together before joining with other patterns
Use external compute for vg materialization
Suggests to evaluate the scope at the query optimization time
Specifies name of the cached dataset to use
Options how joins are distributed over unions of VGs. Either whenever possible (ALWAYS), never (OFF), or based on the cost of distributing the join (DEFAULT)
Cardinality estimation threshold to detect a non-selective full-text search pattern so that more selective parts of the query can be evaluated first.
Enumerates variables for which equality (i.e. ==) should be treated as identity (i.e. sameTerm in SPARQL)
Use external compute properties for vg materialization
Suggests the cardinality of the following graph pattern
Specifies how edge property patterns like '<<?s :p ?o>> :q ?t' should be evaluated: direct: first by :p (embedded predicate), then by :q (outside predicate) inverse: first by :q (outside predicate), then by :p (embedded predicate)
Specifies whether sh:targetClass will be evaluated based on rdf:type triples only, without following rdfs:subClassOf relations.
If off, the reasoner will not place a DISTINCT operator on top of the query plan
Specifies the strategy to evaluate DESCRIBE queries (either built-in or custom)
Limits the number of validation results returned per shape
Specifies how paths should be traversed: lazy: search is stopped after each new path is found so it can be returned (not available for PATHS ALL queries) eager: all reachable nodes are reached first
Limits the number of solutions that are prefetch from a service. Defaults to 10000.
Specifies how the optimizer tries to push filters down the query plan: aggressive: every filter will be pushed as deep down as possible default: the optimizer will decide how deep to push based on other factors, e.g. estimated cardinality off: the optimization is off
Specifies query decomposition strategy: aggressive: always decompose joins on the subject variable default: let the optimizer decide based on other factors, e.g. available indexes off: don't decompose group graph patterns
Specifies if the optimizer should try to use the literal index, e.g. for numbers, if available
Enables or disables the Virtual Transparency feature
Limits the number of results that a pattern evaluated at optimization time is allowed to produce
Maximum number of patterns that can be selected by the optimizer to evaluate before a full-text search pattern
Maximum value of query limit for considering streaming join strategy For queries with higher limit, the optimizer will not try to eliminate pipeline breaker operators (unless explicitly requested with join.choice.strategy hint)
How to translate to SQL when the fields for the returned solution can come from multiple mappings: coalesced: returns the fields from each mapping in its own field and null for all other fields. embedded: creates two fields for each result, one for the field’s type and one for the field’s value.
Threshold of maximum cardinality of patterns that can be selected by the optimizer to evaluate before a full-text search pattern
Specifies if the query should use the new block-based query executor (BARQ) or the legacy row-based query executor.The hint can only be used in the preamble and applies to the entire query.
Use partition columns for external vg materialization
Toggles plan cache for this query If Off, the query will be optimized without any plan cache lookup
Maximum number of elements in VALUES nodes VALUES with more elements will not be rewritten into UNIONs
Disables reorder.solution.modifiers optimizer
Disables optionals.constraint.pull optimizer
Disables property.paths.reachability optimizer
Disables filters.push.services optimizer
Disables projections.push.services optimizer