**Usage**
Postgres, MySQL, and Oracle support the expression `LEFT JOIN ... ON 1 = 1`, but ClickHouse does not.

It may be possible to replace `LEFT JOIN ... ON 1 = 1` with `CROSS JOIN`, but I want to use the query in the same form for lots of databases.

Please support the expression `LEFT JOIN ... ON 1 = 1`.


**Detailed SQL**
```SQL
CREATE TABLE test
(
    `name` Nullable(String),
    `id` int
)
ENGINE = Log();

insert into test values ('a', 1) ('b', 2) (null, 3);

select * from test t1 left join (select * from test ) t2 on 1 = 1   
-- DB::Exception: Not equi-join ON expression: 1 = 1. No columns in one of equality side.: While processing 1 = 1.
```

{
public:
    NotJoinedHash(const HashJoin & parent_, UInt64 max_block_size_)
        : parent(parent_), max_block_size(max_block_size_)
    {}
    Block getEmptyBlock() override { return parent.savedBlockSample().cloneEmpty(); }
    size_t fillColumns(MutableColumns & columns_right) override
    {
        size_t rows_added = 0;
        auto fill_callback = [&](auto, auto strictness, auto & map)
        {
            rows_added = fillColumnsFromMap<strictness>(map, columns_right);
        };
        if (!joinDispatch(parent.kind, parent.strictness, parent.data->maps.front(), fill_callback))
            throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown JOIN strictness '{}' (must be on of: ANY, ALL, ASOF)", parent.strictness);
        if constexpr (!multiple_disjuncts)
        {
            fillNullsFromBlocks(columns_right, rows_added);
        }
        return rows_added;
    }
private:
    const HashJoin & parent;
    UInt64 max_block_size;
    std::any position;
    std::optional<HashJoin::BlockNullmapList::const_iterator> nulls_position;
    std::optional<BlocksList::const_iterator> used_position;
    template <ASTTableJoin::Strictness STRICTNESS, typename Maps>
    size_t fillColumnsFromMap(const Maps & maps, MutableColumns & columns_keys_and_right)