Join order optimization is one of the critical stages in query optimization, where the goal is to determine the most efficient sequence in which joins should be performed (Selinger et al., 1979). Join order optimization plays a central role, as the order of joins determines whether a query finishes in seconds or hours, especially in large databases (Neumann and Radke, 2018). The problem is a well-researched NP-hard problem (Ibaraki and Kameda, 1984) with various exhaustive and heuristic solutions (Leis et al., 2015; Steinbrunn et al., 1997). The central position of join order optimization in database research is also evident in the new research field where quantum computing is applied to database optimization and data management (Schönberger, 2022; Uotila, 2022). In this subfield, the join order selection problem is the most studied (Schönberger et al., 2023a; Winker et al., 2023a; Schönberger et al., 2023c; Nayak et al., 2024; Franz et al., 2024; Schönberger et al., 2023b; Saxena et al., 2024; Liu et al., 2025; Çalikyilmaz et al., 2023). In contrast, other quantum computing problems related to database and data management include index selection (Gruenwald et al., 2023; Trummer and Venturelli, 2024), cardinality and query metric estimations (Uotila, 2024a, 2025b; Kittelmann et al., 2024), transaction scheduling (Bittner and Groppe, 2020; Nayak et al., 2025), resource allocation (Uotila and Lu, 2023; Trummer, 2025), schema matching (Fritsch and Scherzinger, 2023), relational deep learning (Vogrin et al., 2024), and multiple query optimization (Trummer and Koch, 2016).

Despite the interest in optimizing databases with quantum computers, demonstrating a clear quantum advantage in database-related problems remains open. Generally, demonstrating an advantage of quantum over classical algorithms has proved challenging in practice. Some experiments demonstrate specific forms of quantum advantage (Arute et al., 2019; Harrow and Montanaro, 2017; Kim et al., 2023; King et al., 2024; Madsen et al., 2022; Zhong et al., 2020; Zhu et al., 2021), but none show widely accepted benefits over classical algorithms in real-life applications. On the other hand, some algorithms such as Shor's (1994) and Grover's (1996) algorithms show a provable advantage over the best classical algorithms on fault-tolerant quantum computers, which do not yet exist.

Since demonstrating benefits from current quantum computers has proved challenging, Schönberger et al. (2023b) suggested moving from quantum hardware to quantum-inspired hardware, especially in join order optimization. They argued that special-purpose solvers and hardware, such as digital annealers, should be used. While they demonstrated that this direction is promising and feasible, they did not extensively examine the potential benefits of modifying the underlying quantum optimization model, which has been similar to the previous mixed-integer linear programming solution for the join order selection problem (Trummer and Koch, 2017).

If we seek (database) applications that are likely to benefit from quantum computing, one of our central arguments is that we might want to move from quadratic to higher-order models. Focusing on the quantum computing paradigm that is restricted to quadratic interactions between qubits, previous studies has shown that there are only particular problems where these devices beat classical computers (Denchev et al., 2016; King et al., 2024). On the other hand, there is no evidence that this advantage would transfer to practically relevant problems (Willsch et al., 2022).

In this study, we depart from quadratic models and instead investigate higher-order binary optimization. As a continuation of the idea to revise the underlying assumptions about hardware (relaxing from quantum to quantum-inspired), we suggest applying a special optimization model, a higher-order binary optimization model, which is a relaxation of the previously widely used quadratic model (Schönberger et al., 2023a; Trummer and Koch, 2017; Schönberger et al., 2023b,c; Nayak et al., 2024; Saxena et al., 2024). We develop three higher-order binary optimization formulations for the join order selection problem in relational databases, with a focus on left-deep join trees. We present two theoretical results that connect the performance of these methods to the classical dynamic programming and greedy algorithms. Finally, we demonstrate the utility of the proposed algorithms by evaluating the methods on quantum annealers and classical solvers. This evaluation also demonstrates differences between quantum annealers and classical solvers at a concrete application-level problem.

The previous quantum computing formulations for the join order selection problem did not benefit from the query graph's structure, which we encode in the optimization problem formulations. By using information from the query graphs and assuming that cross products are computationally expensive, we can reduce the size of the optimization problems. The other critical scalability finding lies in the selection of binary variables. With a clever choice of binary variables, we can compute the cost precisely and reduce the number of variables and their types. The previous studies (Schönberger et al., 2023a,b) has used four variable types (variables for relations, joins, predicates, and cost approximation). We decrease this number to one variable type, which works in most cases, except for clique graphs, which require two types.

Quantum computing research for database applications has not provided many precise theoretical results regarding the performance of the developed methods. In this study, we prove two bounds for our methods, which connect the quantum algorithms to the classical ones. This is important because it helps in understanding the capabilities of current quantum computation solutions compared to established classical methods.

The key contributions are as follows:

The structure of the article is as follows. First, we formally state the join order selection problem, discuss the quadratic and higher-order binary optimization models, and define their connection to quantum computing. Then, we present the main algorithms. We prove the theoretical bounds for the accuracy of the methods. We summarize the results from the experimental evaluation and discuss how our contributions relate to previous studies on solving the join order selection problem using quantum computing. The implementation is available on GitHub (Uotila, 2025a).

In this section, we develop two higher-order unconstrained binary optimization (HUBO) problems that encode the cost function (Equation 2) for left-deep join order selection problems. We will later focus on the validity constraint separately. Since validity will be built on the cost formulation, we present the cost formulation first. Compared to previous quantum computing research on join order optimization, we formulate the optimization problem from the perspective of joins, instead of relations (Schönberger et al., 2023a). This represents a new conceptual angle to the problem, which makes the formulations substantially distinct. The other new viewpoint is to encode the costs into coefficients of the HUBO polynomial, instead of encoding them with slack variables. This eliminates the need to estimate costs and use additional variables or qubits for encoding in the problem formulation.

The monomials in the HUBO formulation identify a specific join order path. The coefficients in the formulation describe the intermediate costs. Activating combinations of binary variables enables us to compute total join order costs for various join orders through activated monomials. Thus, the cost HUBO is the sum of terms, and we show that the minimum of the polynomial corresponds to the cost of the optimal plan.

Given a query graph G, the number of required joins to create a valid left-deep join tree is |V| − 1, where |V| is the number of nodes (i.e., relations or tables) in query graph G. This is easy to see since the first join is performed between two relations, and after that, every join includes one more relation until all the relations have been joined.

Our algorithm is designed to rank joins, and the ranking determines the order of the joins. This means a join (i.e., edge in the query graph G) has a rank 0 ≤ r < |V| − 1 if the join should be performed after all the lower rank joins are performed. We need |V| − 1 rank values to create a left-deep join order plan. Having |V| − 1 rank values applies to left-deep join plans but not bushy ones. For bushy plans, we can join multiple relations simultaneously, meaning that some of the joins can have the same rank, i.e., appear at the same level in the join tree. It will be part of future research to tackle these cases.

Initially, any join, i.e., edge (R_i, R_j) ∈ G, can have any rank 0 ≤ r < |V| − 1. Hence, we define the binary variables of our HUBO problems to be

where the indices i and j refer to the edge (R_i, R_j) ∈ G, where R_i and R_j are relations and r denotes the rank. Hence, our model consists of (|V| − 1)|E| binary variables since for every rank value 0 ≤ r < |V| − 1, we have |E| many joins (edges) from which we can choose the join.

The interpretation of these binary variables is as follows: If xi,jr=1, then the join (R_i, R_j) should be performed at rank r. Now the join (R_i, R_j) is not necessarily between the relations R_i and R_j since at r > 0, the left relation is an intermediate result of type R_k1 ⋈ … ⋈ R_i ⋈ … ⋈ R_kn for some indices k₁, …, k_n. Therefore, each tuple (R_i, R_j) represents a logical join predicate defined in the query graph, not a physical join operation in an execution plan.

Example 3.1. Consider that we have a simple, complete query graph of four relations {0, 1, 2, 3}. Thus, we have |V| = 4 relations, |E| = 6 possible joins, and (|V| − 1)|E| = 24 binary variables. Depending on the selectivities and cardinalities, an example solution that the model can return is x0,10=1, x1,21=1, and x2,32=1, which gives us the left-deep join tree [[0, 1], 2], 3]. The solution is not unique; also, x0,10=1, x0,21=1, and x2,32=1 produce the same plan with the same cost.

For a HUBO formulation to be effective, its objective function must be constructed so that the minimizing point also represents a valid solution. In this case, validity refers to the join tree's adherence to the query graph, as defined in the Background section. All valid solutions are usable, although they might not minimize the cost. In this section, we present two approaches to encoding the validity of solutions: cost function-dependent and cost function-independent. A cost function-dependent approach is easy to construct but produces a larger number of higher-order terms. The cost function-independent approach is closer to the standard QUBO formulations and identifies a set of constraints that the formulation must satisfy. The advantage of the second formulation is that its terms are primarily quadratic, which makes it easier to optimize in practice.

This section proves two theorems that provide bounds for the quality of the solutions that can theoretically be achieved with the proposed HUBO formulations for the join order selection problem. We introduced the classical baseline algorithms in Algorithms 1, 2. We emphasize that the HUBO formulations and the proofs are constructed to respect the underlying query graph. This means that the algorithms assume that cross products are expensive and could be avoided. Beneficial cross products can be explicitly encoded by adding an edge to the query graph with a selectivity of 1, and the proofs apply to cases with cross products by considering clique graphs where some of the selectivities are 1. While our formulation does not automatically discover such cross products, it can optimize them if they are provided, and this is a promising direction for future research.

By the definition of binary variables in Equation 8, we can prove the theorems by induction on the rank parameter r in the proposed HUBO constructions, as well as the iterations in the dynamic programming and greedy algorithms. Our proof strategy is to show that for every plan considered by the classical algorithms, there is a corresponding assignment in our HUBO formulation with the same cost, such that this assignment is also a minimizing solution to the HUBO problem.

Lemma 1. Let G = (V, E) be a query graph and let x ∈ {0, 1}^{|V| − 1} be a binary vector. Let H_val be the validity constraint consisting of constraints in Equations 12, 13. If the cost-dependent validity constraint evaluates H_val(x) = 0, then vector x encodes a valid left-deep plan.

Proof. First, assume that the cost-dependent validity constraint evaluates H_val(x) = 0. The first constraint in Equation 12 is

where h=∏r=0|V|-2xir,jrr for some indices i_r and j_r for r = 0, …, |V| − 2 that depend on the query graph. This constraint is always non-negative since it is squared. It is positive, except when exactly one of the terms in the sum ∑h∈Hh is 1 when the constraint evaluates to 0. The sum ∑h∈Hh evaluates to 1 when there is exactly one term h such that all the variables in the product h=∏r=0|V|-2xir,jrr are true. This combination of activated variables is the valid join tree that the objective function returns as a solution to the minimization problem.

By construction of H (Algorithm 3), every monomial h ∈ H encodes a left-deep sequence since

These features define a valid left-deep plan. Therefore, the unique x selected above maps to a valid left-deep join plan that respects the query graph G.

Lemma 2. Let G = (V, E) be a query graph and let x ∈ {0, 1}^{|V| − 1} be a binary vector. If the cost-independent validity constraint evaluates H_val(x) = 0, then x encodes a valid left-deep plan.

Proof. We divide the proof into two parts depending on the structure of the query graph.

Clique graphs. In the case of clique graphs, the used validity constraints are as follows.

Assume that the cost-independent validity constraint evaluates H_val(x) = 0. Since every constraint is non-negative, this means that they have to evaluate to 0. The first point ensures that there are exactly |V| − 1 edges, and the second point ensures that the graph is connected. Thus, it is a tree. The last point ensures that every relation appears in the tree, and thus, it is a valid join tree.

The previous constraints are sufficient to also encode a left-deep join tree without additional constraints. For r = 0, the subgraph S₀ contains two relations. The join e_{r + 1} at rank r + 1 must connect to the join e_r at rank r by the constraint in Equation 14. Since the overall graph of joins is a tree, adding e_{r + 1} cannot form a cycle with the previously selected joins. This implies that e_{r + 1} must connect exactly one new relation to the set of relations S_r. Therefore, this progressive inclusion of exactly one new relation at each step defines a left-deep join plan.

Chain, star, cycle, and tree graphs. In this case, the used validity constraints are as follows:

Define Ar={(i,j)∈E∣xi,jr=1} for each 0 ≤ r ≤ |V| − 1. Assuming the previous points and H_val(x) = 0, we obtain A₀ ⊂ A₁ ⊂ ⋯ ⊂ A_{|V| − 2}. From the first point, it follows that |A_r| = r + 1, and the second point ensures that A_{r − 1} ⊂ A_r. Thus, exactly one new join is added at each step. Moreover, the unique new join added when passing from A_{r − 1} to A_r shares exactly one endpoint with the current result.

Next, we consider the structure. For chain, star, and cycle queries, Equation 18 gives a negative reward for each pair of same-rank joins that share exactly one endpoint. Summing over all pairs at rank r forces A_r to be a single connected component because disconnected elements are penalized. For proper trees, the constraint in Equation 19 enforces exactly r adjacent pairs among the possibilities. That is a characterization of a tree on r + 2 vertices with r + 1 edges, which makes A_r connected and acyclic.

Since |A_r| = r + 1 and A_r is connected, it defines a tree. Since A_r = A_{r − 1} ∪ {e_r} and A_{r − 1} is connected and acyclic, the only way how A_r is a tree is that the edge e_r shares exactly one endpoint with A_{r − 1}. This indicates that the plan is left-deep.

Theorem 3. Let G = (V, E) be a query graph. Define binary variables xi,jr∈{0,1} for each rank r ∈ {0, …, |V| − 1} and join edge (i, j) ∈ E as we defined in the context of binary variables in Equation 8. Let H_cost be the precise HUBO formulation obtained by Algorithm 3 with the coefficients given by Equation 11. This means that every rank-r term corresponds to extending a connected subgraph by one adjacent edge and carries the cardinality-based cost contribution defined in Equation 1. Let H_val be any of the validity encodings in Section 4. Consider

with a constant C > 0 chosen so that valid solutions are always preferred to any invalid ones. Let x^⋆ minimize H_full. Then, the solution x^⋆ encodes a valid left-deep plan T^⋆ without cross products whose cost equals the cost from the DP algorithm without cross products:

where C(·) is the recursive cost in Equation 2.

Proof. The proof consists of three parts, which ensure the optimality and correctness: a bijection between valid DP plans and assignments without penalty, a rank-wise construction which identifies costs from H_cost with costs in the DP table, and penalty scaling to enforce feasibility.

1. Based on Lemma 1 and Lemma 2, it suffices to show that the set

is in a bijective relationship with the set

Every left-deep plan T can be written as a sequence of joins (e₁, e₁, …, e_{|V| − 1}), where each e_r = (i_r, j_r) ∈ E joins exactly one new relation to the current connected join tree, and the join tree T adheres to the query graph G in the sense of Subsection 2.1. Define a mapping ϕ:T → {0, 1}^{|V| − 1} by

By construction, the image ϕ(T) = x satisfies the following properties:

Since this means that for the element ϕ(T) = x every constraint is satisfied, we obtain that H_val(x) = 0. Conversely, for any x for which H_val(x) = 0, the previous constraints are satisfied, which means that exactly one join per rank is activated, and we obtain a connected left-deep sequence of edges in E. This decodes a plan T = ϕ⁻¹(x). Thus, we obtain the bijection between sets in Equations 21, 22.

2. Next, we define a rank-wise invariant, which is proved to preserve the join order cost. The DP algorithm (without cross products) maintains, at iteration r, the DP table, which records all connected subplans with r + 1 relations. It also stores for each subplan its total cost under the cost function in Equation 2. Then, there exists an invariant I(r) as follows. After Algorithm 3 has generated all terms up to rank r, for every connected subplan S with |S| = r + 1, there exist a set of variables {xik,jkk}k=0r such that

Proof of the invariant. First, we consider the base case, when r = 0. By Algorithm 3, all the joins between the leaf relations are included in the cost function H_cost: α_{(i, j)} = f_{i, j}|R_i||R_j|, which is exactly the DP cost of that binary join. Thus, I(0) holds.

Inductive step. Assume that I(r − 1) holds. This means that there exists a connected subgraph S_prev of size r. Fix a connected subplan S of size r + 1. By construction, Algorithm 3 forms S by extending S_prev with an adjacent edge (i′, j′) ∈ E that adds exactly one new relation. The new coefficient attached to this extension is α_S, which is computed with Equation 11. This is precisely the cardinality, i.e., cost for the intermediate result after adding the (i′, j′) join. Summing this with the previously accumulated coefficients for S_prev, which exists by the induction assumption, gives exactly the DP total cost for S. Hence, I(r) holds.

Thus, for any left-deep plan T and x = ϕ(T), when applying I(|V| − 2), we obtain

3. Finally, we consider optimality under the penalty constraint. We choose the constant C so that any violation of the validity constraint H_val raises the objective by at least the maximum possible variation of H_cost. Since every term in H_cost is positive, the simple choice for this is C: = H_cost(1), where 1 = (1, …, 1). Then, any minimizer x^⋆ of H_full must satisfy Hval(x⋆)=0. This means that x^⋆ is valid and corresponds to some left-deep plan T^⋆, which we showed earlier.

Among such valid assignments, minimizing H_full becomes identical to minimizing H_cost. Restricting to valid x = ϕ(T) gives H_cost(x) = C(T), as we pointed out in Equation 23. Therefore, x^⋆ encodes a plan T^⋆ whose cost is minimal among all left-deep plans without cross products. This is exactly the DP optimum without cross products: Hcost(x⋆)=C(T⋆). This finalizes the proof.

Theorem 4. Let H_cost be the heuristic method's cost HUBO defined in subsection 3.2. Let x^⋆ be a minimizer of H_cost. Then, H_cost(x) ≤ C_greedy, i.e., the cost from the greedy algorithm gives an upper bound for the cost from the heuristic algorithm.

Proof. We use the same rank index r ∈ [0, |V| − 2] as in the previous theorem, and use the same cost–coefficient mapping defined in Equation 11. We again prove an invariant with respect to r as follows.

Invariant: For each rank r, the greedy algorithm's partial plan, T_r, is contained within the set of partial plans (the frontier) maintained by the heuristic HUBO construction.

Base case (r = 0): The heuristic algorithm includes all leaf joins at rank 0, so it contains the cheapest leaf join chosen by the classical greedy algorithm.

Inductive step: Assume the invariant holds for rank r − 1, meaning T_{r − 1} is in the heuristic's frontier. The greedy algorithm extends T_{r − 1} by selecting the adjacent relation that minimizes the local cost increment. According to Equation 11, these local increments are precisely the α-coefficients for the valid rank-r extensions of T_{r − 1} in the HUBO formulation.

At rank r, the heuristic selects the top extensions based on the smallest coefficients. Since the greedy choice corresponds to the extension with the smallest increment (and thus smallest coefficient), it is guaranteed to be selected by the heuristic. Thus, the partial plan T_r is included in the heuristic's frontier, completing the induction.

Because the heuristic frontier contains the entire greedy path T₀, …, T_{|V| − 2} and the HUBO objective function sums the same local increment that the greedy algorithm accumulates along that path, there exists a feasible assignment x′ whose value equals the cost C_greedy from the classical greedy algorithm. The minimizer x^⋆ of H_cost among valid plans cannot therefore do any worse, and we obtain

In this section, we present the results of a comprehensive experimental evaluation that includes optimizing join order selection on various combinations of query graphs, problem formulations, and classical and quantum optimizers. For each method proposed in this article, we evaluate the technique against five common query graph types: clique, star, chain, cycle, and tree. Each query graph is labeled using the format 'Graph name - number of nodes'. For each graph type and graph size, we sampled 20 query graph instances with random cardinalities and selectivities. The cardinalities are randomly sampled from the range 10 to 50, and selectivity from the interval (0, 1]. The costs are summed over the 20 query graph instances, describing a realistic cumulative error, and scaled with respect to the cost returned from the dynamic programming algorithm with cross products, which is the optimal left-deep plan. This means that the results are compared to the optimal left-deep plans. The code, the exact query graphs, and parameters used for this experimental evaluation are available in the GitHub repository (Uotila, 2025a). Since we have used 20 query graph instances for five different graph types, ranging in size from 3 to 60, and solved them with four different quantum and classical solvers, the total number of optimized problems is in the thousands. We refer to the implementation of our algorithms as Q-Join.

After fixing one of the three proposed methods and a query graph instance, we constructed the corresponding HUBO optimization problem. Then, we submitted the problem for each selected solver. The available solvers include two quantum computing approaches (D-Wave quantum annealer and D-Wave hybrid quantum annealer) and two classical approaches (exact poly solver and Gurobi optimizer). In all cases except the exact poly solver, the HUBO problem needs to be translated into the equivalent QUBO problem.

Our evaluation focuses on solution quality, rather than solver runtime. A direct comparison of execution times is impractical, as system-level latencies heavily influence them. A direct comparison of execution times might be misleading in this scenario because the quantum annealer's microsecond-scale annealing time is only one component of a larger process that includes significant classical overhead from problem embedding and post-processing. The pre- and post-processing latencies include problem encoding, network communication, solver queuing, and interpreting the result. We identify that a meaningful comparison of execution times between classical and quantum systems is still a research question.

Summary of proposed methods. We have proposed three algorithms to solve the join order selection problem with a higher-order unconstrained binary optimization model. Table 1 introduces names for these methods, which are used in this Experimental Evaluation section.

The results should be interpreted as follows. For each case, we have solved the join order selection problem using four different methods: our algorithm in evaluation, dynamic programming without cross products, a greedy algorithm without cross products, and finally, dynamic programming with cross products. Since dynamic programming with cross products produces the optimal left-deep plan, we scale the cumulative cost over 20 different join order optimization problems with this cost. This way, we obtain a metric that enables us to compare these methods without explicitly dealing with cost values. The actual range of costs is arbitrary since the cardinalities and selectivities are randomly sampled. For example, suppose our algorithm has a scaled cost of 1.007. In that case, this means that the cumulative cost of the 20 returned plans from our algorithm is 0.7% larger than the cumulative cost for the optimal plans from dynamic programming with cross products.

In this study, we developed a novel higher-order binary optimization formulation for optimizing join order selection for left-deep query plans. This is a fundamentally new approach to one of the most studied query optimization problems in the database domain. Our formulation is accompanied by formal guarantees, as proven in Theorems 3 and 4. Our method respects query graphs, which makes it distinct from previous formulations. Although this leaves out cross products, it also simplifies problem formulation for certain query graphs. It paves the way for future methods that rely on information about query graphs. As shown in Figure 4, our method requires a relatively small number of binary variables. Finally, we conducted a comprehensive experimental evaluation that demonstrated the usage of quantum annealers in this task, deepened our understanding of differences between quantum and classical solvers in this real-life problem, and showed that the results in Theorems 3 and 4 are respected in practice.

The starting point for our study has been primarily the previous quantum computing formulations (Schönberger et al., 2023a; Winker et al., 2023a; Schönberger et al., 2023c; Nayak et al., 2024; Franz et al., 2024; Schönberger et al., 2023b; Saxena et al., 2024) for the join order selection problem. Our method's scalability in real-life problems outperforms many previous studies (Schönberger et al., 2023a; Franz et al., 2024; Schönberger et al., 2023c), where the authors have demonstrated their algorithms with 2 to 7 relations. The method proposed in the study by Schönberger et al. (2023b) offers the best scalability and accuracy. However, their algorithm lacks a guarantee of optimality and requires the use of more variables (Figure 4). The comparison to this approach showed accuracy similar to our method in small query graphs. We also note that classical solvers compete with the quantum annealers in this task, even though they run locally on a laptop. This demonstrates that quantum annealers are not scalable enough to solve these types of problems efficiently, and their performance is crucially problem-dependent.

Classical approaches for solving HUBO problems typically rely on approximate methods due to the exponential growth in complexity of these problems. Integer programming can be used to find approximate solutions for HUBO problems, but it suffers from scalability issues and does not always ensure feasibility (Munoz, 2017). Machine learning techniques, including graph neural networks, have been explored for approximating HUBO solutions (Schuetz et al., 2022). However, these approaches often require training data and may struggle to generalize to previously unseen instances. Simulated annealing has been applied as another classical strategy for tackling HUBO problems (Wang et al., 2025). While these classical methods are effective for small- and medium-sized instances, they encounter significant challenges as problem size increases, highlighting the potential usability of quantum-native approaches such as QAOA. In theory, the HUBO formulations in this article can be addressed using the same QAOA-based methods employed in Uotila et al. (2025).

Quantum computing for HUBO problems represents an emerging area in the field of quantum optimization. For example, Campbell and Dahl (2022) explored the use of the Quantum Approximate Optimization Algorithm (QAOA) for higher-order graph coloring problems. Techniques such as bias-field digitized counterdiabatic quantum optimization have been developed to enhance the solution of higher-order binary problems (Romero et al., 2025; Cadavid et al., 2025), and various methods have been proposed for optimizing variational quantum circuits tailored to these challenges (Verchere et al., 2023). Higher-order problems have also served as benchmarks for comparing QAOA and quantum annealing performance (Pelofske et al., 2023; Sachdeva et al., 2024; Pelofske et al., 2024b; Gilbert et al., 2023), as well as for studying the scaling behavior and parameter concentration properties of QAOA (Pelofske et al., 2024a). Initial applications for HUBO formulations include higher-order portfolio optimization (Uotila et al., 2025), the formalization of practical matrix multiplication algorithm search (Uotila, 2024b), and optimization in railway rescheduling (Domino et al., 2022). While HUBO formulations are classically challenging, it remains open whether they offer an actual computational advantage on quantum hardware.

Multiple challenges remain. The biggest challenge in our method is the higher-order terms, whose number grows exponentially in some cases. The current HUBO problem formulations also do not account for bushy trees or cross products, which would further enhance the quality of the solution. We are also limited to inner joins and the simple cost model. The problem of optimizing join order selection also relies on cardinality estimations, which is a separate challenge in query optimization. Finally, there is considerable room for improvement in solving HUBO problems on both classical and quantum hardware. Very few methods can effectively tackle HUBO optimization problems. In this regard, quantum computing appears to be theoretically one of the most promising approaches to optimizing complex HUBOs. In future research, we are excited to explore the universal quantum computing capabilities for solving HUBOs. Unfortunately, the problem sizes studied in this work were still too large for the current universal quantum computers.

Previous methods have been limited to inner joins. Extending our binary variables to model non-inner joins is theoretically straightforward, for instance, by adding a component to indicate the join type (inner or outer). While this modification is simple, the cost function and constraints also need adjustments. Since our cost HUBO is explicitly based on the recursive join order cost function, encoding predicate dependencies is also feasible. Our HUBO formulations can be further approximated with other heuristics to make them feasible for solving a larger set of complex query graphs. Exploring these extensions offers promising directions for future research in join order optimization with quantum computing.

In this study, we have developed three novel graph-aware higher-order binary optimization models to solve the join order selection problem in relational databases. The HUBO problems can be divided into cost functions and validity constraints. We presented two new binary optimization formulations for the cost function and proved that one encodes the same join trees as the dynamic programming algorithm without cross products. The other finds plans that are at least as good as those returned by the greedy algorithm without cross products. Finally, we presented a comprehensive experimental evaluation of these algorithms on various quantum and classical solvers. The experimental evaluation demonstrated the practical usability of these HUBO formulations and the fact that we respect the proven bounds in practice. While classical solvers remained competitive, these types of binary optimization models will serve as the essential element for future quantum optimization platforms.