You can use recursion:

WITH RecursiveCombination AS (
    SELECT 
        CAST(non_unique_column AS VARCHAR(255)) AS combination,
        non_unique_column AS last_char
    FROM my_table
    UNION ALL
    SELECT 
        CAST(rc.combination + mt.non_unique_column AS VARCHAR(255)) AS combination,
        mt.non_unique_column AS last_char
    FROM my_table mt
    JOIN RecursiveCombination rc ON mt.non_unique_column > rc.last_char
)
SELECT combination
FROM (
    SELECT DISTINCT combination, LEN(combination) as len_comb
    FROM RecursiveCombination
    WHERE LEN(combination) > 1
) t
ORDER BY t.len_comb, t.combination;

Output:

Try it out here.

The fixed max length of the source table allows a plain join solution, e.g.

declare @x char(1)=char((select ascii(max(non_unique_column))+1 from my_table)); 
with tplus as (
  select * from my_table union select @x
)
select comb
from (
    select replace(
       cast(t1.non_unique_column AS VARCHAR(5)) 
          + t2.non_unique_column 
          + t3.non_unique_column 
          + t4.non_unique_column
          + t5.non_unique_column
                    ,@x,'') comb
    from my_table t1
    join my_table t2 on t1.non_unique_column < t2.non_unique_column
    join tplus t3 on t2.non_unique_column < t3.non_unique_column
    join tplus t4 on t3.non_unique_column < t4.non_unique_column or t4.non_unique_column = @x
    join tplus t5 on t4.non_unique_column < t5.non_unique_column or t5.non_unique_column = @x
) t
order by len(comb), comb

db<>fiddle

Still I'd prefer a recursive one as Sash Sinha suggested.