How to efficiently broadcast the same index across an entire dataframe

Say I have these parts

• out_df: a pandas dataframe with a simple rangeindex as index and then some columns

Could look like this

>> out_df
    Col1  Col2
0    2.3  9.7
1    103  6.5
2    54   3.5

• queries_tuples: a list of tuples, with same length as out_df

Could look like this

>> queries_tuples
[('something_A', 'Something_B', 'Something_C'), 
('something_A', 'Something_B', 'Something_C'),
('something_A', 'Something_B', 'Something_C')]

• names: a list of names for the index names

Could look like

[index_name_1, index_name_2, index_name_3]

Now I want to combine these three to end up with a dataframe, which has a multiindex.
Could look like this

                                                Col1  Col2
index_name_1,  index_name_2,   index_name_3        
'something_A'  'Something_B'  'Something_C'  0   2.3  9.7
                                             1   103  6.5
                                             2   3.5  3.5

Now, this is my current solution

original_names = out_df.index.names
mi = pd.MultiIndex.from_tuples(queries_tuples, names=names)
out_df.set_index(mi, append=True, inplace=True)
names_2 = names + original_names
out_df = out_df.reorder_levels(names_2)

However, I feel like I am really missing out on some performance since all my entries in queries_tuples are identical. In my concrete case the size of the dataframe is quite large (a few million entries) and thus, my current solution is quite slow. Is there some way of exploiting that all entries in queries_tuples are identical and thus, can be "broadcasted" across the entire dataframe?
Or is there an even better way of doing this?
Please help, thanks !

Use pd.concat:

>>> out_df
    Col1  Col2
0    2.3   9.7
1  103.0   6.5
2   54.0   3.5

>>> queries_tuple
[('something_A', 'Something_B', 'Something_C'),
 ('something_A', 'Something_B', 'Something_C'),
 ('something_A', 'Something_B', 'Something_C')]

>>> names
['index_name_1', 'index_name_2', 'index_name_3']

Output:

>>> pd.concat([out_df], keys=[queries_tuples[0]], names=names)

                                           Col1  Col2
index_name_1 index_name_2 index_name_3               
something_A  Something_B  Something_C  0    2.3   9.7
                                       1  103.0   6.5
                                       2   54.0   3.5

Performance for 1,000,000 records:

%timeit pd.concat([out_df], keys=[queries_tuples[0]], names=names)
16.8 ms ± 605 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

I found that MultiIndex.from_product() ended up being about 2x-10x faster than MultiIndex.from_tuples(), depending on the number of rows in the dataframe.

import pandas as pd
import numpy as np


N = 1000000
out_df = pd.DataFrame(np.random.random((N, len(names))))
names = ['index_name_1', 'index_name_2', 'index_name_3']

queries_tuples = ('something_A', 'Something_B', 'Something_C')
product = [[elem] for elem in queries_tuples]
product.append(out_df.index)
mi = pd.MultiIndex.from_product(product, names=names + [out_df.index.name])
out_df.index = mi
print(out_df)

I suspect the speed difference is because from_product() knows that only one possible value can occur in each of the three named columns, so most of the factorization step is skipped.