Non-inner joins + single column filters don't work

[MBkkt]

There 2 reasons:

1. When we do distributeConjuncts we don't account that we can pushdown such filters through such joins
2. Same when we actually enumerate plans in makeJoins

TEST_F(PlanTest, pushdownFilterThroughJoin) {
  testConnector_->addTable("t1", ROW({"id1", "data1"}, {BIGINT(), BIGINT()}));
  testConnector_->addTable("t2", ROW({"id2", "data2"}, {BIGINT(), BIGINT()}));

  auto makePlan = [&](lp::JoinType joinType) {
    lp::PlanBuilder::Context ctx{kTestConnectorId};
    return lp::PlanBuilder{ctx}
        .from({"t1"})
        .join(lp::PlanBuilder{ctx}.from({"t2"}), "id1 = id2", joinType)
        .filter("data1 IS NULL")
        .filter("data2 IS NULL")
        .build();
  };

  {
    SCOPED_TRACE("Inner Join");
    auto logicalPlan = makePlan(lp::JoinType::kInner);
    auto matcher = core::PlanMatcherBuilder{}
                       .tableScan("t1")
                       .filter("data1 IS NULL")
                       .hashJoin(
                           core::PlanMatcherBuilder{}
                               .tableScan("t2")
                               .filter("data2 IS NULL")
                               .build(),
                           core::JoinType::kInner)
                       .build();
    auto plan = toSingleNodePlan(logicalPlan);
    AXIOM_ASSERT_PLAN(plan, matcher);
  }
  {
    SCOPED_TRACE("Left Join");
    auto logicalPlan = makePlan(lp::JoinType::kLeft);
    auto matcher = core::PlanMatcherBuilder{}
                       .tableScan("t1")
                       .filter("data1 IS NULL")
                       .hashJoin(
                           core::PlanMatcherBuilder{}.tableScan("t2").build(),
                           core::JoinType::kLeft)
                       .filter("data2 IS NULL")
                       .build();
    auto plan = toSingleNodePlan(logicalPlan);
    AXIOM_ASSERT_PLAN(plan, matcher);
  }
  {
    SCOPED_TRACE("Right Join");
    auto logicalPlan = makePlan(lp::JoinType::kRight);
    auto matcher = core::PlanMatcherBuilder{}
                       .tableScan("t1")
                       .hashJoin(
                           core::PlanMatcherBuilder{}
                               .tableScan("t2")
                               .filter("data2 IS NULL")
                               .build(),
                           core::JoinType::kRight)
                       .filter("data1 IS NULL")
                       .build();
    auto plan = toSingleNodePlan(logicalPlan);
    AXIOM_ASSERT_PLAN(plan, matcher);
  }
  {
    SCOPED_TRACE("Full Join");
    auto logicalPlan = makePlan(lp::JoinType::kFull);
    auto matcher = core::PlanMatcherBuilder{}
                       .tableScan("t1")
                       .hashJoin(
                           core::PlanMatcherBuilder{}.tableScan("t2").build(),
                           core::JoinType::kFull)
                       .filter("data1 IS NULL AND data2 IS NULL")
                       .build();
    auto plan = toSingleNodePlan(logicalPlan);
    AXIOM_ASSERT_PLAN(plan, matcher);
  }
}

[mbasmanova]

I believe the root cause of this issue is that columns produced by the LEFT / RIGHT / FULL joins are indistinguishable from columns produced by their left and right sides. Hence, I believe a proper solution would be to extend JoinEdge to add columns produced by the join. For LEFT join, we would track columns produced by right side, for RIGHT join - columns produced by left side, for FULL join - all columns. Once we do that, the pushdown of expressions that depend on right-side columns of the LEFT join would no longer be possible.

[mbasmanova]

CC: @oerling

[MBkkt]

@mbasmanova In theory we can use these columns from join to understand, but it's unnecessary, slower and more complicated.

Instead I already implemented solution that relies on tables.
Because we don't need to distinguish "left table column a" with "left table column b", we need only table level granularity.
This is already done.