It is possible using unless operator:

item_stock unless item_purchases

Results in a vector consisting of the elements of item_stock for which there are no elements in item_purchases with exactly matching label sets. All matching elements in both vectors are dropped.

Note that the metrics in question do not have 'exactly matching label sets' (name is common but count and in_stock are not). In this case you can use on to set the list of labels to match:

item_stock unless on(name) item_purchases

Best workaround: union with "or"

The closest I've come uses set operations to execute the query as two branches - one for the "inner join" side, and one that's an anti-join that returns only LHS rows that don't match the RHS. This is very verbose if the LHS is a nontrivial expression instead of a simple stand-alone metric, and it's really inefficient too.

(
  important_metric{}
  * on (join_labels)
    group_left(info_label)
    group by (join_labels, info_label) (
      workload_priorities_info{}
    )
)
# if there's no series on the LHS with the same labels as the RHS after ignoring
# the "info_label" label on each side, add the RHS series to the output, otherwise
# output the LHS series.
or ignoring (info_label)
important_metric{}

with inputs

important_metric{join_labels="1"} 100
important_metric{join_labels="2"} 64
important_metric{join_labels="3"} 5

workload_priorities_info{join_labels="1",info_label="highprio"}
workload_priorities_info{join_labels="3",info_label="lowprio"}

this produces

{join_labels="1",info_label="highprio"} 100
{join_labels="2"} 64
{join_labels="3",info_label="lowprio"} 5

Based on Proposal: PromQL arithmetic with default value, or outer join (issue#13625) this is probably the best workaround that is currently possible.

SQL analogues for comparison

The SQL translation of this would be something like

# inner join to find rows with matching info metrics
SELECT
  important_metric.value * workload_priorities_info.value,
  important_metric.join_labels,
  workload_priorities_info.info_label
FROM important_metric
INNER JOIN workload_priorities_info USING (join_labels)
# append two sets of rows
UNION ALL
# find rows that do NOT have any matching info-metric and append them to
# the result set
SELECT important_metric.value,
  important_metric.join_labels,
  NULL
FROM important_metric
LEFT JOIN INNER JOIN workload_priorities_info USING (join_labels)
WHERE workload_priorities_info.info_label IS NULL

where what we want is the equivalent of

SELECT
  important_metric.value * coalesce(workload_priorities_info.value, 1),
  important_metric.join_labels,
  workload_priorities_info.info_label
FROM important_metric
LEFT JOIN workload_priorities_info USING (join_labels)

For now the only solution I have is with query duplication:

(
  (sum(kafka_consumergroup_lag[1d]) by (consumergroup) >= 100)
  * on(consumergroup) group_left(team)
  catalog_entities_info
)
or ignoring(team) (sum(kafka_consumergroup_lag[1d]) by (consumergroup) >= 100)

First half will add team label where possible, and second or half will add missed data (important to merge vectors while ignoring added team label, otherwise we will have duplicates).

Prometheus is lacking outer join functionality. You can see very in-depth description of situation and possible workaround for left outer join from Brian Brazil here.

Based on the same logic full outer join for your example will look like this:

sum by (a) (foo) + sum by (a) (bar) #inner join
  or sum by (a) (foo) #with first line ~left outer join
  or sum by (a) (bar) #with first line ~right outer join