select_cases.json

[
  {
    "comment": "No column referenced",
    "query": "select 1 from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select 1 from `user` where 1 != 1",
        "Query": "select 1 from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "'*' expression for simple route",
    "query": "select user.* from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.* from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.* from `user` where 1 != 1",
        "Query": "select `user`.* from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "unqualified '*' expression for simple route",
    "query": "select * from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "join on sharding column with limit - should be a simple scatter query and limit on top with non resolved columns",
    "query": "select * from user u join user_metadata um on u.id = um.user_id where foo=41 limit 20",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user u join user_metadata um on u.id = um.user_id where foo=41 limit 20",
      "Instructions": {
        "OperatorType": "Limit",
        "Count": "20",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from `user` as u, user_metadata as um where 1 != 1",
            "Query": "select * from `user` as u, user_metadata as um where foo = 41 and u.id = um.user_id limit 20",
            "Table": "`user`, user_metadata"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_metadata"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select with timeout directive sets QueryTimeout in the route",
    "query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from `user`",
        "QueryTimeout": 1000,
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select aggregation with timeout directive sets QueryTimeout in the route",
    "query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ count(*) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ count(*) from user",
      "Instructions": {
        "OperatorType": "Aggregate",
        "Variant": "Scalar",
        "Aggregates": "sum_count_star(0) AS count(*)",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select count(*) from `user` where 1 != 1",
            "Query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ count(*) from `user`",
            "QueryTimeout": 1000,
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select limit with timeout directive sets QueryTimeout in the route",
    "query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from user limit 10",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from user limit 10",
      "Instructions": {
        "OperatorType": "Limit",
        "Count": "10",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from `user` where 1 != 1",
            "Query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from `user` limit 10",
            "QueryTimeout": 1000,
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select limit with timeout directive sets QueryTimeout in the route",
    "query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from main.unsharded limit 10",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from main.unsharded limit 10",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded where 1 != 1",
        "Query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from unsharded limit 10",
        "QueryTimeout": 1000,
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select with partial scatter directive",
    "query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS */ * from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS */ * from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS */ * from `user`",
        "ScatterErrorsAsWarnings": true,
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select aggregation with partial scatter directive",
    "query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from user",
      "Instructions": {
        "OperatorType": "Aggregate",
        "Variant": "Scalar",
        "Aggregates": "sum_count_star(0) AS count(*)",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select count(*) from `user` where 1 != 1",
            "Query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from `user`",
            "ScatterErrorsAsWarnings": true,
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select aggregation with partial scatter directive - added comments to try to confuse the hint extraction",
    "query": "/*VT_SPAN_CONTEXT=123*/select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "/*VT_SPAN_CONTEXT=123*/select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from user",
      "Instructions": {
        "OperatorType": "Aggregate",
        "Variant": "Scalar",
        "Aggregates": "sum_count_star(0) AS count(*)",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select count(*) from `user` where 1 != 1",
            "Query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ count(*) from `user`",
            "ScatterErrorsAsWarnings": true,
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select limit with partial scatter directive",
    "query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ * from user limit 10",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ * from user limit 10",
      "Instructions": {
        "OperatorType": "Limit",
        "Count": "10",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from `user` where 1 != 1",
            "Query": "select /*vt+ SCATTER_ERRORS_AS_WARNINGS=1 */ * from `user` limit 10",
            "ScatterErrorsAsWarnings": true,
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "qualified '*' expression for simple route",
    "query": "select user.* from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.* from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.* from `user` where 1 != 1",
        "Query": "select `user`.* from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "fully qualified '*' expression for simple route",
    "query": "select user.user.* from user.user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.user.* from user.user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.* from `user` where 1 != 1",
        "Query": "select `user`.* from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "select * from authoritative table",
    "query": "select * from authoritative",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from authoritative",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select user_id, col1, col2 from authoritative where 1 != 1",
        "Query": "select user_id, col1, col2 from authoritative",
        "Table": "authoritative"
      },
      "TablesUsed": [
        "user.authoritative"
      ]
    }
  },
  {
    "comment": "select * from join of authoritative tables",
    "query": "select * from authoritative a join authoritative b on a.user_id=b.user_id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from authoritative a join authoritative b on a.user_id=b.user_id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select a.user_id, a.col1, a.col2, b.user_id, b.col1, b.col2 from authoritative as a, authoritative as b where 1 != 1",
        "Query": "select a.user_id, a.col1, a.col2, b.user_id, b.col1, b.col2 from authoritative as a, authoritative as b where a.user_id = b.user_id",
        "Table": "authoritative"
      },
      "TablesUsed": [
        "user.authoritative"
      ]
    }
  },
  {
    "comment": "test table lookup failure for authoritative code path",
    "query": "select a.* from authoritative",
    "plan": "Unknown table 'a'",
    "skip_e2e": true
  },
  {
    "comment": "select * from qualified authoritative table",
    "query": "select a.* from authoritative a",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select a.* from authoritative a",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select user_id, col1, col2 from authoritative as a where 1 != 1",
        "Query": "select user_id, col1, col2 from authoritative as a",
        "Table": "authoritative"
      },
      "TablesUsed": [
        "user.authoritative"
      ]
    }
  },
  {
    "comment": "select * from intermixing of authoritative table with non-authoritative results in no expansion",
    "query": "select * from authoritative join user on authoritative.user_id=user.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from authoritative join user on authoritative.user_id=user.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from authoritative, `user` where 1 != 1",
        "Query": "select * from authoritative, `user` where authoritative.user_id = `user`.id",
        "Table": "`user`, authoritative"
      },
      "TablesUsed": [
        "user.authoritative",
        "user.user"
      ]
    }
  },
  {
    "comment": "select authoritative.* with intermixing still expands",
    "query": "select user.id, a.*, user.col1 from authoritative a join user on a.user_id=user.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id, a.*, user.col1 from authoritative a join user on a.user_id=user.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.id, a.user_id, a.col1, a.col2, `user`.col1 from authoritative as a, `user` where 1 != 1",
        "Query": "select `user`.id, a.user_id, a.col1, a.col2, `user`.col1 from authoritative as a, `user` where a.user_id = `user`.id",
        "Table": "`user`, authoritative"
      },
      "TablesUsed": [
        "user.authoritative",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "auto-resolve anonymous columns for simple route",
    "query": "select anon_col from user join user_extra on user.id = user_extra.user_id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select anon_col from user join user_extra on user.id = user_extra.user_id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select anon_col from `user`, user_extra where 1 != 1",
        "Query": "select anon_col from `user`, user_extra where `user`.id = user_extra.user_id",
        "Table": "`user`, user_extra"
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "json_arrayagg in single sharded query",
    "query": "select count(1) from user where id = 'abc' group by n_id having json_arrayagg(a_id) = '[]'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select count(1) from user where id = 'abc' group by n_id having json_arrayagg(a_id) = '[]'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select count(1) from `user` where 1 != 1 group by n_id",
        "Query": "select count(1) from `user` where id = 'abc' group by n_id having json_arrayagg(a_id) = '[]'",
        "Table": "`user`",
        "Values": [
          "'abc'"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "json_objectagg in single sharded query",
    "query": "select count(1) from user where id = 'abc' group by n_id having json_objectagg(a_id, b_id) = '[]'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select count(1) from user where id = 'abc' group by n_id having json_objectagg(a_id, b_id) = '[]'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select count(1) from `user` where 1 != 1 group by n_id",
        "Query": "select count(1) from `user` where id = 'abc' group by n_id having json_objectagg(a_id, b_id) = '[]'",
        "Table": "`user`",
        "Values": [
          "'abc'"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "unsupported json aggregation expressions in scatter query",
    "query": "select count(1) from user where cola = 'abc' group by n_id having json_arrayagg(a_id) = '[]'",
    "plan": "VT12001: unsupported: in scatter query: aggregation function 'json_arrayagg(a_id)'",
    "skip_e2e": true
  },
  {
    "comment": "Cannot auto-resolve for cross-shard joins",
    "query": "select col from user join user_extra",
    "plan": "Column 'col' in field list is ambiguous",
    "skip_e2e": true
  },
  {
    "comment": "Auto-resolve should work if unique vindex columns are referenced",
    "query": "select id, user_id from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select id, user_id from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select id from `user` where 1 != 1",
            "Query": "select id from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_id from user_extra where 1 != 1",
            "Query": "select user_id from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "database calls should be substituted",
    "query": "select database() from dual",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select database() from dual",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          ":__vtdbname as database()"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "last_insert_id for unsharded route",
    "query": "select last_insert_id() as x from main.unsharded",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select last_insert_id() as x from main.unsharded",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select :__lastInsertId as x from unsharded where 1 != 1",
        "Query": "select :__lastInsertId as x from unsharded",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select from dual on unqualified keyspace",
    "query": "select @@session.auto_increment_increment from dual",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select @@session.auto_increment_increment from dual",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select @@auto_increment_increment from dual where 1 != 1",
        "Query": "select @@auto_increment_increment from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "select from pinned table",
    "query": "select * from pin_test",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from pin_test",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from pin_test where 1 != 1",
        "Query": "select * from pin_test",
        "Table": "pin_test",
        "Values": [
          "'\ufffd'"
        ],
        "Vindex": "binary"
      },
      "TablesUsed": [
        "user.pin_test"
      ]
    }
  },
  {
    "comment": "prefixing dual with a keyspace should not work",
    "query": "select 1 from user.dual",
    "plan": "table dual not found",
    "skip_e2e": true
  },
  {
    "comment": "RHS route referenced",
    "query": "select user_extra.id from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user_extra.id from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from `user` where 1 != 1",
            "Query": "select 1 from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.id from user_extra where 1 != 1",
            "Query": "select user_extra.id from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Both routes referenced",
    "query": "select user.col, user_extra.id from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.col, user_extra.id from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.id from user_extra where 1 != 1",
            "Query": "select user_extra.id from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Expression with single-route reference",
    "query": "select user.col, user_extra.id + user_extra.col from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.col, user_extra.id + user_extra.col from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.id + user_extra.col from user_extra where 1 != 1",
            "Query": "select user_extra.id + user_extra.col from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "subquery with an aggregation in order by that can be merged into a single route",
    "query": "select col, trim((select user_name from user where id = 3)) val from user_extra where user_id = 3 group by col order by val",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select col, trim((select user_name from user where id = 3)) val from user_extra where user_id = 3 group by col order by val",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select col, trim((select user_name from `user` where 1 != 1)) as val from user_extra where 1 != 1 group by col",
        "Query": "select col, trim((select user_name from `user` where id = 3)) as val from user_extra where user_id = 3 group by col order by trim((select `user`.user_name from `user` where `user`.id = 3)) asc",
        "Table": "user_extra",
        "Values": [
          "3"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Jumbled references",
    "query": "select user.col, user_extra.id, user.col2 from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.col, user_extra.id, user.col2 from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0,L:1",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col, `user`.col2 from `user` where 1 != 1",
            "Query": "select `user`.col, `user`.col2 from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.id from user_extra where 1 != 1",
            "Query": "select user_extra.id from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Comments",
    "query": "select /* comment */ user.col from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /* comment */ user.col from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select /* comment */ `user`.col from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from user_extra where 1 != 1",
            "Query": "select /* comment */ 1 from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "for update",
    "query": "select user.col from user join user_extra for update",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.col from user join user_extra for update",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user` for update",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from user_extra where 1 != 1",
            "Query": "select 1 from user_extra for update",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Field query should work for joins select bind vars",
    "query": "select user.id, (select user.id+outm.m+unsharded.m from unsharded) from user join unsharded outm",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id, (select user.id+outm.m+unsharded.m from unsharded) from user join unsharded outm",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "JoinVars": {
          "user_id": 0
        },
        "TableName": "`user`_unsharded",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.id, `user`.id from `user` where 1 != 1",
            "Query": "select `user`.id, `user`.id from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select (select :user_id + outm.m + unsharded.m from unsharded where 1 != 1) as `(select ``user``.id + outm.m + unsharded.m from unsharded)` from unsharded as outm where 1 != 1",
            "Query": "select (select :user_id + outm.m + unsharded.m from unsharded) as `(select ``user``.id + outm.m + unsharded.m from unsharded)` from unsharded as outm",
            "Table": "unsharded"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Case preservation",
    "query": "select user.Col, user_extra.Id from user join user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.Col, user_extra.Id from user join user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.Col from `user` where 1 != 1",
            "Query": "select `user`.Col from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.Id from user_extra where 1 != 1",
            "Query": "select user_extra.Id from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "syntax error",
    "query": "the quick brown fox",
    "plan": "syntax error at position 4 near 'the'",
    "skip_e2e": true
  },
  {
    "comment": "Hex number is not treated as a simple value",
    "query": "select * from user where id = 0x04",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where id = 0x04",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 0x04",
        "Table": "`user`",
        "Values": [
          "_binary'\u0004'"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "Selection but explicitly ignore a vindex",
    "query": "select * from user ignore vindex (user_index) where id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user ignore vindex (user_index) where id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 1",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Selection but make the planner explicitly use a vindex",
    "query": "select intcol, id from user use vindex (name_user_map) where costly = 'aa' and name = 'bb' and id = 3",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select intcol, id from user use vindex (name_user_map) where costly = 'aa' and name = 'bb' and id = 3",
      "Instructions": {
        "OperatorType": "VindexLookup",
        "Variant": "Equal",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "Values": [
          "'bb'"
        ],
        "Vindex": "name_user_map",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
            "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
            "Table": "name_user_vdx",
            "Values": [
              "::name"
            ],
            "Vindex": "user_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "ByDestination",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select intcol, id from `user` where 1 != 1",
            "Query": "select intcol, id from `user` where costly = 'aa' and `name` = 'bb' and id = 3",
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Vindex hint on a non-existing vindex",
    "query": "select * from user use vindex (does_not_exist) where id = 1",
    "plan": "VT09021: Vindex 'does_not_exist' does not exist in table 'user.user'",
    "skip_e2e": true
  },
  {
    "comment": "sharded limit offset",
    "query": "select user_id from music order by user_id limit 10, 20",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user_id from music order by user_id limit 10, 20",
      "Instructions": {
        "OperatorType": "Limit",
        "Count": "20",
        "Offset": "10",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_id, weight_string(user_id) from music where 1 != 1",
            "OrderBy": "(0|1) ASC",
            "Query": "select user_id, weight_string(user_id) from music order by music.user_id asc limit 30",
            "ResultColumns": 1,
            "Table": "music"
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "sharded limit offset with arguments",
    "query": "select user_id from music order by user_id limit :limit, :offset",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user_id from music order by user_id limit :limit, :offset",
      "Instructions": {
        "OperatorType": "Limit",
        "Count": ":offset",
        "Offset": ":limit",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_id, weight_string(user_id) from music where 1 != 1",
            "OrderBy": "(0|1) ASC",
            "Query": "select user_id, weight_string(user_id) from music order by music.user_id asc limit :__upper_limit",
            "ResultColumns": 1,
            "Table": "music"
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Sharding Key Condition in Parenthesis",
    "query": "select * from user where name ='abc' AND (id = 4) limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where name ='abc' AND (id = 4) limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where `name` = 'abc' and id = 4 limit 5",
        "Table": "`user`",
        "Values": [
          "4"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Multiple parenthesized expressions",
    "query": "select * from user where (id = 4) AND (name ='abc') limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where (id = 4) AND (name ='abc') limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 4 and `name` = 'abc' limit 5",
        "Table": "`user`",
        "Values": [
          "4"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Multiple parenthesized expressions",
    "query": "select * from user where (id = 4 and name ='abc') limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where (id = 4 and name ='abc') limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 4 and `name` = 'abc' limit 5",
        "Table": "`user`",
        "Values": [
          "4"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Column Aliasing with Table.Column",
    "query": "select user0_.col as col0_ from user user0_ where id = 1 order by user0_.col desc limit 2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user0_.col as col0_ from user user0_ where id = 1 order by user0_.col desc limit 2",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select user0_.col as col0_ from `user` as user0_ where 1 != 1",
        "Query": "select user0_.col as col0_ from `user` as user0_ where id = 1 order by user0_.col desc limit 2",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "Column Aliasing with Column",
    "query": "select user0_.col as col0_ from user user0_ where id = 1 order by col0_ desc limit 3",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user0_.col as col0_ from user user0_ where id = 1 order by col0_ desc limit 3",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select user0_.col as col0_ from `user` as user0_ where 1 != 1",
        "Query": "select user0_.col as col0_ from `user` as user0_ where id = 1 order by user0_.col desc limit 3",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "Booleans and parenthesis",
    "query": "select * from user where (id = 1) AND name = true limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where (id = 1) AND name = true limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 1 and `name` = true limit 5",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Column as boolean-ish",
    "query": "select * from user where (id = 1) AND name limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where (id = 1) AND name limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 1 and `name` limit 5",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "PK as fake boolean, and column as boolean-ish",
    "query": "select * from user where (id = 5) AND name = true limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where (id = 5) AND name = true limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 5 and `name` = true limit 5",
        "Table": "`user`",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "top level subquery in select",
    "query": "select a, (select col from user) from unsharded",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select a, (select col from user) from unsharded",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutValue",
        "PulloutVars": [
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select col from `user` where 1 != 1",
            "Query": "select col from `user`",
            "Table": "`user`"
          },
          {
            "InputName": "Outer",
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select a, :__sq1 /* INT16 */ as `(select col from ``user``)` from unsharded where 1 != 1",
            "Query": "select a, :__sq1 /* INT16 */ as `(select col from ``user``)` from unsharded",
            "Table": "unsharded"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "sub-expression subquery in select",
    "query": "select a, 1+(select col from user) from unsharded",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select a, 1+(select col from user) from unsharded",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutValue",
        "PulloutVars": [
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select col from `user` where 1 != 1",
            "Query": "select col from `user`",
            "Table": "`user`"
          },
          {
            "InputName": "Outer",
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select a, 1 + :__sq1 /* INT16 */ as `1 + (select col from ``user``)` from unsharded where 1 != 1",
            "Query": "select a, 1 + :__sq1 /* INT16 */ as `1 + (select col from ``user``)` from unsharded",
            "Table": "unsharded"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select * from derived table expands specific columns",
    "query": "select * from (select user.id id1, user_extra.id id2 from user join user_extra) as t",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from (select user.id id1, user_extra.id id2 from user join user_extra) as t",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select t.id1 from (select `user`.id as id1 from `user` where 1 != 1) as t where 1 != 1",
            "Query": "select t.id1 from (select `user`.id as id1 from `user`) as t",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select t.id2 from (select user_extra.id as id2 from user_extra where 1 != 1) as t where 1 != 1",
            "Query": "select t.id2 from (select user_extra.id as id2 from user_extra) as t",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "duplicate columns not allowed in derived table",
    "query": "select * from (select user.id, user_extra.id from user join user_extra) as t",
    "plan": "Duplicate column name 'id'",
    "skip_e2e": true
  },
  {
    "comment": "non-existent symbol in cross-shard derived table",
    "query": "select t.col from (select user.id from user join user_extra) as t",
    "plan": "column 't.col' not found",
    "skip_e2e": true
  },
  {
    "comment": "union with the same target shard",
    "query": "select * from music where user_id = 1 union select * from user where id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from music where user_id = 1 union select * from user where id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from music where 1 != 1 union select * from `user` where 1 != 1",
        "Query": "select * from music where user_id = 1 union select * from `user` where id = 1",
        "Table": "`user`, music",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "union with the same target shard last_insert_id",
    "query": "select *, last_insert_id() from music where user_id = 1 union select * from user where id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select *, last_insert_id() from music where user_id = 1 union select * from user where id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select *, :__lastInsertId as `last_insert_id()` from music where 1 != 1 union select * from `user` where 1 != 1",
        "Query": "select *, :__lastInsertId as `last_insert_id()` from music where user_id = 1 union select * from `user` where id = 1",
        "Table": "`user`, music",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "unsharded union in derived table",
    "query": "select * from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) a",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) a",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from (select col1, col2 from unsharded where 1 != 1 union select col1, col2 from unsharded where 1 != 1) as a where 1 != 1",
        "Query": "select * from (select col1, col2 from unsharded where id = 1 union select col1, col2 from unsharded where id = 3) as a",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    }
  },
  {
    "comment": "unsharded union in subquery",
    "query": "select id, name from unsharded where id in (select id from unsharded where id = 1 union select id from unsharded where id = 3)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select id, name from unsharded where id in (select id from unsharded where id = 1 union select id from unsharded where id = 3)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select id, `name` from unsharded where 1 != 1",
        "Query": "select id, `name` from unsharded where id in (select id from unsharded where id = 1 union select id from unsharded where id = 3)",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    }
  },
  {
    "comment": "(select id from unsharded) union (select id from unsharded_auto) order by id limit 5",
    "query": "(select id from unsharded) union (select id from unsharded_auto) order by id limit 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "(select id from unsharded) union (select id from unsharded_auto) order by id limit 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select id from unsharded where 1 != 1 union select id from unsharded_auto where 1 != 1",
        "Query": "select id from unsharded union select id from unsharded_auto order by id asc limit 5",
        "Table": "unsharded, unsharded_auto"
      },
      "TablesUsed": [
        "main.unsharded",
        "main.unsharded_auto"
      ]
    }
  },
  {
    "comment": "unsharded union",
    "query": "select id from unsharded union select id from unsharded_auto union select id from unsharded_auto where id in (132)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select id from unsharded union select id from unsharded_auto union select id from unsharded_auto where id in (132)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select id from unsharded where 1 != 1 union select id from unsharded_auto where 1 != 1 union select id from unsharded_auto where 1 != 1",
        "Query": "select id from unsharded union select id from unsharded_auto union select id from unsharded_auto where id in (132)",
        "Table": "unsharded, unsharded_auto"
      },
      "TablesUsed": [
        "main.unsharded",
        "main.unsharded_auto"
      ]
    }
  },
  {
    "comment": "unsharded nested union",
    "query": "(select id from unsharded union select id from unsharded_auto) union (select id from unsharded_auto union select name from unsharded)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "(select id from unsharded union select id from unsharded_auto) union (select id from unsharded_auto union select name from unsharded)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select id from unsharded where 1 != 1 union select id from unsharded_auto where 1 != 1 union select id from unsharded_auto where 1 != 1 union select `name` from unsharded where 1 != 1",
        "Query": "select id from unsharded union select id from unsharded_auto union select id from unsharded_auto union select `name` from unsharded",
        "Table": "unsharded, unsharded_auto"
      },
      "TablesUsed": [
        "main.unsharded",
        "main.unsharded_auto"
      ]
    }
  },
  {
    "comment": "unsharded nested union with limit",
    "query": "(select id from unsharded order by id asc limit 1) union (select id from unsharded order by id desc limit 1) order by id asc limit 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "(select id from unsharded order by id asc limit 1) union (select id from unsharded order by id desc limit 1) order by id asc limit 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "(select id from unsharded where 1 != 1) union (select id from unsharded where 1 != 1)",
        "Query": "(select id from unsharded order by id asc limit 1) union (select id from unsharded order by id desc limit 1) order by id asc limit 1",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    }
  },
  {
    "comment": "routing rules: ensure directives are not lost",
    "query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from route2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from route2",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded as route2 where 1 != 1",
        "Query": "select /*vt+ QUERY_TIMEOUT_MS=1000 */ * from unsharded as route2",
        "QueryTimeout": 1000,
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "routing table on music",
    "query": "select * from second_user.bar where id > 2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from second_user.bar where id > 2",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from music as bar where 1 != 1",
        "Query": "select * from music as bar where id > 2",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "testing SingleRow Projection",
    "query": "select 42",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 42",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          "42 as 42"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "avg in sharded keyspace with group by without selecting the group by columns",
    "query": "select avg(intcol) as avg_col from user group by textcol1, textcol2 order by textcol1, textcol2;",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select avg(intcol) as avg_col from user group by textcol1, textcol2 order by textcol1, textcol2;",
      "Instructions": {
        "OperatorType": "SimpleProjection",
        "ColumnNames": [
          "0:avg_col"
        ],
        "Columns": "0",
        "Inputs": [
          {
            "OperatorType": "Projection",
            "Expressions": [
              "sum(intcol) / count(intcol) as avg_col",
              ":1 as textcol1",
              ":2 as textcol2"
            ],
            "Inputs": [
              {
                "OperatorType": "Aggregate",
                "Variant": "Ordered",
                "Aggregates": "sum(0) AS avg_col, sum_count(3) AS count(intcol)",
                "GroupBy": "1 COLLATE latin1_swedish_ci, (2|4) COLLATE ",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select sum(intcol) as avg_col, textcol1, textcol2, count(intcol), weight_string(textcol2) from `user` where 1 != 1 group by textcol1, textcol2, weight_string(textcol2)",
                    "OrderBy": "1 ASC COLLATE latin1_swedish_ci, (2|4) ASC COLLATE ",
                    "Query": "select sum(intcol) as avg_col, textcol1, textcol2, count(intcol), weight_string(textcol2) from `user` group by textcol1, textcol2, weight_string(textcol2) order by textcol1 asc, textcol2 asc",
                    "Table": "`user`"
                  }
                ]
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "don't filter on the vtgate",
    "query": "select 42 from dual where false",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 42 from dual where false",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "None",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 42 from dual where 1 != 1",
        "Query": "select 42 from dual where 0",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Complex expression in a subquery used in IN clause of an aggregate query",
    "query": "select count(*) from user where user.id = 2 or user.id in (select id from unsharded_a where colb = 2)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select count(*) from user where user.id = 2 or user.id in (select id from unsharded_a where colb = 2)",
      "Instructions": {
        "OperatorType": "Aggregate",
        "Variant": "Scalar",
        "Aggregates": "sum_count_star(0) AS count(*)",
        "Inputs": [
          {
            "OperatorType": "UncorrelatedSubquery",
            "Variant": "PulloutIn",
            "PulloutVars": [
              "__sq_has_values",
              "__sq1"
            ],
            "Inputs": [
              {
                "InputName": "SubQuery",
                "OperatorType": "Route",
                "Variant": "Unsharded",
                "Keyspace": {
                  "Name": "main",
                  "Sharded": false
                },
                "FieldQuery": "select id from unsharded_a where 1 != 1",
                "Query": "select id from unsharded_a where colb = 2",
                "Table": "unsharded_a"
              },
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select count(*) from `user` where 1 != 1",
                "Query": "select count(*) from `user` where `user`.id = 2 or :__sq_has_values and `user`.id in ::__sq1",
                "Table": "`user`"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded_a",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Complex expression in a subquery used in NOT IN clause of an aggregate query",
    "query": "select count(*) from user where user.id = 2 or user.id not in (select id from unsharded_a where colb = 2)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select count(*) from user where user.id = 2 or user.id not in (select id from unsharded_a where colb = 2)",
      "Instructions": {
        "OperatorType": "Aggregate",
        "Variant": "Scalar",
        "Aggregates": "sum_count_star(0) AS count(*)",
        "Inputs": [
          {
            "OperatorType": "UncorrelatedSubquery",
            "Variant": "PulloutNotIn",
            "PulloutVars": [
              "__sq_has_values",
              "__sq1"
            ],
            "Inputs": [
              {
                "InputName": "SubQuery",
                "OperatorType": "Route",
                "Variant": "Unsharded",
                "Keyspace": {
                  "Name": "main",
                  "Sharded": false
                },
                "FieldQuery": "select id from unsharded_a where 1 != 1",
                "Query": "select id from unsharded_a where colb = 2",
                "Table": "unsharded_a"
              },
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select count(*) from `user` where 1 != 1",
                "Query": "select count(*) from `user` where `user`.id = 2 or (not :__sq_has_values or `user`.id not in ::__sq1)",
                "Table": "`user`"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded_a",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "testing SingleRow Projection with arithmetics",
    "query": "select 42+2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 42+2",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          "44 as 42 + 2"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "sql_calc_found_rows without limit",
    "query": "select sql_calc_found_rows * from music where user_id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select sql_calc_found_rows * from music where user_id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from music where 1 != 1",
        "Query": "select * from music where user_id = 1",
        "Table": "music",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "sql_calc_found_rows with limit",
    "query": "select sql_calc_found_rows * from music limit 100",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select sql_calc_found_rows * from music limit 100",
      "Instructions": {
        "OperatorType": "SQL_CALC_FOUND_ROWS",
        "Inputs": [
          {
            "OperatorType": "Limit",
            "Count": "100",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select * from music where 1 != 1",
                "Query": "select * from music limit 100",
                "Table": "music"
              }
            ]
          },
          {
            "OperatorType": "Aggregate",
            "Variant": "Scalar",
            "Aggregates": "sum_count_star(0) AS count(*)",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select count(*) from music where 1 != 1",
                "Query": "select count(*) from music",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "sql_calc_found_rows with SelectEqualUnique plans",
    "query": "select sql_calc_found_rows * from music where user_id = 1 limit 2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select sql_calc_found_rows * from music where user_id = 1 limit 2",
      "Instructions": {
        "OperatorType": "SQL_CALC_FOUND_ROWS",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from music where 1 != 1",
            "Query": "select * from music where user_id = 1 limit 2",
            "Table": "music",
            "Values": [
              "1"
            ],
            "Vindex": "user_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select count(*) from music where 1 != 1",
            "Query": "select count(*) from music where user_id = 1",
            "Table": "music",
            "Values": [
              "1"
            ],
            "Vindex": "user_index"
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "sql_calc_found_rows with group by and having",
    "query": "select sql_calc_found_rows user_id, count(id) from music group by user_id having count(user_id) = 1 order by user_id limit 2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select sql_calc_found_rows user_id, count(id) from music group by user_id having count(user_id) = 1 order by user_id limit 2",
      "Instructions": {
        "OperatorType": "SQL_CALC_FOUND_ROWS",
        "Inputs": [
          {
            "OperatorType": "Limit",
            "Count": "2",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select user_id, count(id), weight_string(user_id) from music where 1 != 1 group by user_id",
                "OrderBy": "(0|2) ASC",
                "Query": "select user_id, count(id), weight_string(user_id) from music group by user_id having count(user_id) = 1 order by music.user_id asc limit 2",
                "ResultColumns": 2,
                "Table": "music"
              }
            ]
          },
          {
            "OperatorType": "Aggregate",
            "Variant": "Scalar",
            "Aggregates": "sum_count_star(0) AS count(*)",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select count(*) from (select user_id, count(id) from music where 1 != 1 group by user_id) as t where 1 != 1",
                "Query": "select count(*) from (select user_id, count(id) from music group by user_id having count(user_id) = 1) as t",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "sql_calc_found_rows in sub queries",
    "query": "select * from music where user_id IN (select sql_calc_found_rows * from music limit 10)",
    "plan": "Incorrect usage/placement of 'SQL_CALC_FOUND_ROWS'",
    "skip_e2e": true
  },
  {
    "comment": "sql_calc_found_rows in derived table",
    "query": "select sql_calc_found_rows * from (select sql_calc_found_rows * from music limit 10) t limit 1",
    "plan": "Incorrect usage/placement of 'SQL_CALC_FOUND_ROWS'",
    "skip_e2e": true
  },
  {
    "comment": "select from unsharded keyspace into dumpfile",
    "query": "select * from main.unsharded into Dumpfile 'x.txt'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from main.unsharded into Dumpfile 'x.txt'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded where 1 != 1",
        "Query": "select * from unsharded into dumpfile 'x.txt'",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select from unsharded keyspace into outfile",
    "query": "select * from main.unsharded into outfile 'x.txt' character set binary fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\n'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from main.unsharded into outfile 'x.txt' character set binary fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\n'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded where 1 != 1",
        "Query": "select * from unsharded into outfile 'x.txt' character set binary fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\\n'",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select from unsharded keyspace into outfile s3",
    "query": "select * from main.unsharded into outfile s3 'out_file_name' character set binary format csv header fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\n' manifest on overwrite off",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from main.unsharded into outfile s3 'out_file_name' character set binary format csv header fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\n' manifest on overwrite off",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded where 1 != 1",
        "Query": "select * from unsharded into outfile s3 'out_file_name' character set binary format csv header fields terminated by 'term' optionally enclosed by 'c' escaped by 'e' lines starting by 'a' terminated by '\\n' manifest on overwrite off",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "left join with a dual table on left - merge-able",
    "query": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id=1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id=1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select t.title, `user`.col from (select 'hello' as title from dual where 1 != 1) as t left join `user` on `user`.id = 1 where 1 != 1",
        "Query": "select t.title, `user`.col from (select 'hello' as title from dual) as t left join `user` on `user`.id = 1",
        "Table": "`user`, dual",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "left join with a dual table on left - non-merge-able",
    "query": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id <= 4",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id <= 4",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "LeftJoin",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "dual_`user`",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Reference",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select t.title from (select 'hello' as title from dual where 1 != 1) as t where 1 != 1",
            "Query": "select t.title from (select 'hello' as title from dual) as t",
            "Table": "dual"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user` where `user`.id <= 4",
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "left join with dual non-merge-able with predicate with cross dependencies",
    "query": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id <= 4 and t.title = user.col",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from (select 'hello' as title) as t left join user on user.id <= 4 and t.title = user.col",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "LeftJoin",
        "JoinColumnIndexes": "L:0,R:0",
        "JoinVars": {
          "t_title": 0
        },
        "TableName": "dual_`user`",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Reference",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select t.title from (select 'hello' as title from dual where 1 != 1) as t where 1 != 1",
            "Query": "select t.title from (select 'hello' as title from dual) as t",
            "Table": "dual"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user` where `user`.col = :t_title /* VARCHAR */ and `user`.id <= 4",
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "right join with a dual table on left",
    "query": "select t.title, user.col from (select 'hello' as title) as t right join user on user.id<=4",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from (select 'hello' as title) as t right join user on user.id<=4",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select t.title, `user`.col from `user` left join (select 'hello' as title from dual where 1 != 1) as t on `user`.id <= 4 where 1 != 1",
        "Query": "select t.title, `user`.col from `user` left join (select 'hello' as title from dual) as t on `user`.id <= 4",
        "Table": "`user`, dual"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "right join with a dual table on right - merge-able",
    "query": "select t.title, user.col from user right join (select 'hello' as title) as t on user.id=1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from user right join (select 'hello' as title) as t on user.id=1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select t.title, `user`.col from (select 'hello' as title from dual where 1 != 1) as t left join `user` on `user`.id = 1 where 1 != 1",
        "Query": "select t.title, `user`.col from (select 'hello' as title from dual) as t left join `user` on `user`.id = 1",
        "Table": "`user`, dual",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "right join with a dual table on right - non-merge-able",
    "query": "select t.title, user.col from user right join (select 'hello' as title) as t on user.id>=4",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.title, user.col from user right join (select 'hello' as title) as t on user.id>=4",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "LeftJoin",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "dual_`user`",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Reference",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select t.title from (select 'hello' as title from dual where 1 != 1) as t where 1 != 1",
            "Query": "select t.title from (select 'hello' as title from dual) as t",
            "Table": "dual"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user` where `user`.id >= 4",
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "Union after into outfile is incorrect",
    "query": "select id from user into outfile 'out_file_name' union all select id from music",
    "plan": "syntax error at position 55 near 'union'",
    "skip_e2e": true
  },
  {
    "comment": "Into outfile s3 in derived table is incorrect",
    "query": "select id from (select id from user into outfile s3 'inner_outfile') as t2",
    "plan": "syntax error at position 41 near 'into'",
    "skip_e2e": true
  },
  {
    "comment": "Into outfile s3 in derived table with union incorrect",
    "query": "select id from (select id from user into outfile s3 'inner_outfile' union select 1) as t2",
    "plan": "syntax error at position 41 near 'into'",
    "skip_e2e": true
  },
  {
    "comment": "select (select u.id from user as u where u.id = 1), a.id from user as a where a.id = 1",
    "query": "select (select u.id from user as u where u.id = 1), a.id from user as a where a.id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select (select u.id from user as u where u.id = 1), a.id from user as a where a.id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select (select u.id from `user` as u where 1 != 1), a.id from `user` as a where 1 != 1",
        "Query": "select (select u.id from `user` as u where u.id = 1), a.id from `user` as a where a.id = 1",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "Add two tables with the same column in a join",
    "query": "select t.id, s.id from user t join user_extra s on t.id = s.user_id join unsharded",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.id, s.id from user t join user_extra s on t.id = s.user_id join unsharded",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0,R:1",
        "TableName": "unsharded_`user`, user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select 1 from unsharded where 1 != 1",
            "Query": "select 1 from unsharded",
            "Table": "unsharded"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select t.id, s.id from `user` as t, user_extra as s where 1 != 1",
            "Query": "select t.id, s.id from `user` as t, user_extra as s where t.id = s.user_id",
            "Table": "`user`, user_extra"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "((((select 1))))",
    "query": "((((select 1))))",
    "plan": {
      "QueryType": "SELECT",
      "Original": "((((select 1))))",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          "1 as 1"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Merging dual with user",
    "query": "select 42, id from dual, user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 42, id from dual, user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select 42, id from dual, `user` where 1 != 1",
        "Query": "select 42, id from dual, `user`",
        "Table": "`user`, dual"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "subquery in select expression of derived table",
    "query": "select t.a from (select (select col from user limit 1) as a from user join user_extra) t",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select t.a from (select (select col from user limit 1) as a from user join user_extra) t",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "UncorrelatedSubquery",
            "Variant": "PulloutValue",
            "PulloutVars": [
              "__sq1"
            ],
            "Inputs": [
              {
                "InputName": "SubQuery",
                "OperatorType": "Limit",
                "Count": "1",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select col from `user` where 1 != 1",
                    "Query": "select col from `user` limit 1",
                    "Table": "`user`"
                  }
                ]
              },
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select t.a from (select :__sq1 /* INT16 */ as a from `user` where 1 != 1) as t where 1 != 1",
                "Query": "select t.a from (select :__sq1 /* INT16 */ as a from `user`) as t",
                "Table": "`user`"
              }
            ]
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from user_extra where 1 != 1",
            "Query": "select 1 from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "ORDER BY subquery",
    "query": "select (select col from user limit 1) as a from user join user_extra order by a",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select (select col from user limit 1) as a from user join user_extra order by a",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "UncorrelatedSubquery",
            "Variant": "PulloutValue",
            "PulloutVars": [
              "__sq1"
            ],
            "Inputs": [
              {
                "InputName": "SubQuery",
                "OperatorType": "Limit",
                "Count": "1",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select col from `user` where 1 != 1",
                    "Query": "select col from `user` limit 1",
                    "Table": "`user`"
                  }
                ]
              },
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select :__sq1 /* INT16 */ as a from `user` where 1 != 1",
                "Query": "select :__sq1 /* INT16 */ as a from `user`",
                "Table": "`user`"
              }
            ]
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from user_extra where 1 != 1",
            "Query": "select 1 from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "plan test for a natural character set string",
    "query": "select N'string' from dual",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select N'string' from dual",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          "'string' as N'string'"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "select expression having dependencies on both sides of a join",
    "query": "select user.id * user_id as amount from user, user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id * user_id as amount from user, user_extra",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0",
        "JoinVars": {
          "user_id": 0
        },
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.id from `user` where 1 != 1",
            "Query": "select `user`.id from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select :user_id * user_id as amount from user_extra where 1 != 1",
            "Query": "select :user_id * user_id as amount from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Straight Join ensures specific ordering of joins",
    "query": "select user.id, user_extra.user_id from user straight_join user_extra where user.id = user_extra.foo",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id, user_extra.user_id from user straight_join user_extra where user.id = user_extra.foo",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "JoinVars": {
          "user_id": 0
        },
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.id from `user` where 1 != 1",
            "Query": "select `user`.id from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.user_id from user_extra where 1 != 1",
            "Query": "select user_extra.user_id from user_extra where user_extra.foo = :user_id",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Dual query should be handled on the vtgate even with a LIMIT",
    "query": "select last_insert_id() limit 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select last_insert_id() limit 1",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          ":__lastInsertId as last_insert_id()"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "PullOut subquery with an aggregation that should be typed in the final output",
    "query": "select (select sum(col) from user) from user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select (select sum(col) from user) from user_extra",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutValue",
        "PulloutVars": [
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Aggregate",
            "Variant": "Scalar",
            "Aggregates": "sum(0) AS sum(col)",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select sum(col) from `user` where 1 != 1",
                "Query": "select sum(col) from `user`",
                "Table": "`user`"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select CAST(:__sq1 AS DECIMAL(0, 0)) as `(select sum(col) from ``user``)` from user_extra where 1 != 1",
            "Query": "select CAST(:__sq1 AS DECIMAL(0, 0)) as `(select sum(col) from ``user``)` from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Straight Join preserved in MySQL query",
    "query": "select user.id, user_extra.user_id from user straight_join user_extra where user.id = user_extra.user_id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id, user_extra.user_id from user straight_join user_extra where user.id = user_extra.user_id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.id, user_extra.user_id from `user` straight_join user_extra on `user`.id = user_extra.user_id where 1 != 1",
        "Query": "select `user`.id, user_extra.user_id from `user` straight_join user_extra on `user`.id = user_extra.user_id",
        "Table": "`user`, user_extra"
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "correlated subquery in exists clause",
    "query": "select col from user where exists(select user_id from user_extra where user_id = 3 and user_id < user.id)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select col from user where exists(select user_id from user_extra where user_id = 3 and user_id < user.id)",
      "Instructions": {
        "OperatorType": "SimpleProjection",
        "ColumnNames": [
          "0:col"
        ],
        "Columns": "0",
        "Inputs": [
          {
            "OperatorType": "SemiJoin",
            "JoinVars": {
              "user_id": 1
            },
            "TableName": "`user`_user_extra",
            "Inputs": [
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select col, `user`.id from `user` where 1 != 1",
                "Query": "select col, `user`.id from `user`",
                "Table": "`user`"
              },
              {
                "InputName": "SubQuery",
                "OperatorType": "Route",
                "Variant": "EqualUnique",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select 1 from user_extra where 1 != 1",
                "Query": "select 1 from user_extra where user_id = 3 and user_id < :user_id limit 1",
                "Table": "user_extra",
                "Values": [
                  "3"
                ],
                "Vindex": "user_index"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "correlated subquery in exists clause with an order by",
    "query": "select col from user where exists(select user_id from user_extra where user_id = 3 and user_id < user.id) order by col",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select col from user where exists(select user_id from user_extra where user_id = 3 and user_id < user.id) order by col",
      "Instructions": {
        "OperatorType": "SimpleProjection",
        "ColumnNames": [
          "0:col"
        ],
        "Columns": "0",
        "Inputs": [
          {
            "OperatorType": "SemiJoin",
            "JoinVars": {
              "user_id": 1
            },
            "TableName": "`user`_user_extra",
            "Inputs": [
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select col, `user`.id from `user` where 1 != 1",
                "OrderBy": "0 ASC",
                "Query": "select col, `user`.id from `user` order by `user`.col asc",
                "Table": "`user`"
              },
              {
                "InputName": "SubQuery",
                "OperatorType": "Route",
                "Variant": "EqualUnique",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select 1 from user_extra where 1 != 1",
                "Query": "select 1 from user_extra where user_id = 3 and user_id < :user_id limit 1",
                "Table": "user_extra",
                "Values": [
                  "3"
                ],
                "Vindex": "user_index"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "correlated subquery having dependencies on two tables",
    "query": "select 1 from user u1, user u2 where exists (select 1 from user_extra ue where ue.col = u1.col and ue.col = u2.col)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from user u1, user u2 where exists (select 1 from user_extra ue where ue.col = u1.col and ue.col = u2.col)",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0",
        "JoinVars": {
          "u1_col": 1
        },
        "TableName": "`user`_`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1, u1.col from `user` as u1 where 1 != 1",
            "Query": "select 1, u1.col from `user` as u1",
            "Table": "`user`"
          },
          {
            "OperatorType": "SemiJoin",
            "JoinVars": {
              "u2_col": 0
            },
            "TableName": "`user`_user_extra",
            "Inputs": [
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select u2.col from `user` as u2 where 1 != 1",
                "Query": "select u2.col from `user` as u2",
                "Table": "`user`"
              },
              {
                "InputName": "SubQuery",
                "OperatorType": "Limit",
                "Count": "1",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select 1 from user_extra as ue where 1 != 1",
                    "Query": "select 1 from user_extra as ue where ue.col = :u1_col /* INT16 */ and ue.col = :u2_col /* INT16 */ limit 1",
                    "Table": "user_extra"
                  }
                ]
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "correlated subquery using a column twice",
    "query": "select 1 from user u where exists (select 1 from user_extra ue where ue.col = u.col and u.col = ue.col2)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from user u where exists (select 1 from user_extra ue where ue.col = u.col and u.col = ue.col2)",
      "Instructions": {
        "OperatorType": "SimpleProjection",
        "Columns": "0",
        "Inputs": [
          {
            "OperatorType": "SemiJoin",
            "JoinVars": {
              "u_col": 1
            },
            "TableName": "`user`_user_extra",
            "Inputs": [
              {
                "InputName": "Outer",
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select 1, u.col from `user` as u where 1 != 1",
                "Query": "select 1, u.col from `user` as u",
                "Table": "`user`"
              },
              {
                "InputName": "SubQuery",
                "OperatorType": "Limit",
                "Count": "1",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select 1 from user_extra as ue where 1 != 1",
                    "Query": "select 1 from user_extra as ue where ue.col = :u_col /* INT16 */ and ue.col2 = :u_col /* INT16 */ limit 1",
                    "Table": "user_extra"
                  }
                ]
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "correlated subquery that is dependent on one side of a join, fully mergeable",
    "query": "SELECT music.id FROM music INNER JOIN user ON music.user_id = user.id WHERE music.user_id = 5 AND music.id = (SELECT MAX(m2.id) FROM music m2 WHERE m2.user_id = user.id)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music INNER JOIN user ON music.user_id = user.id WHERE music.user_id = 5 AND music.id = (SELECT MAX(m2.id) FROM music m2 WHERE m2.user_id = user.id)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music, `user` where 1 != 1",
        "Query": "select music.id from music, `user` where music.user_id = 5 and music.user_id = `user`.id and music.id = (select max(m2.id) from music as m2 where m2.user_id = `user`.id)",
        "Table": "`user`, music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music",
        "user.user"
      ]
    }
  },
  {
    "comment": "Complex join with multiple conditions merged into single route",
    "query": "select 0 from user as u join user_extra as s on u.id = s.user_id join music as m on m.user_id = u.id and (s.foo or m.bar)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 0 from user as u join user_extra as s on u.id = s.user_id join music as m on m.user_id = u.id and (s.foo or m.bar)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select 0 from `user` as u, user_extra as s, music as m where 1 != 1",
        "Query": "select 0 from `user` as u, user_extra as s, music as m where u.id = s.user_id and m.user_id = u.id and (s.foo or m.bar)",
        "Table": "`user`, music, user_extra"
      },
      "TablesUsed": [
        "user.music",
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "union as a derived table",
    "query": "select found from (select id as found from user union all (select id from unsharded)) as t",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select found from (select id as found from user union all (select id from unsharded)) as t",
      "Instructions": {
        "OperatorType": "Concatenate",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select id as found from `user` where 1 != 1",
            "Query": "select id as found from `user`",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select id from unsharded where 1 != 1",
            "Query": "select id from unsharded",
            "Table": "unsharded"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user"
      ]
    }
  },
  {
    "comment": "use output column containing data from both sides of the join",
    "query": "select user_extra.col + user.col from user join user_extra on user.id = user_extra.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user_extra.col + user.col from user join user_extra on user.id = user_extra.id",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0",
        "JoinVars": {
          "user_extra_col": 0,
          "user_extra_id": 1
        },
        "TableName": "user_extra_`user`",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_extra.col, user_extra.id from user_extra where 1 != 1",
            "Query": "select user_extra.col, user_extra.id from user_extra",
            "Table": "user_extra"
          },
          {
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select :user_extra_col /* INT16 */ + `user`.col as `user_extra.col + ``user``.col` from `user` where 1 != 1",
            "Query": "select :user_extra_col /* INT16 */ + `user`.col as `user_extra.col + ``user``.col` from `user` where `user`.id = :user_extra_id",
            "Table": "`user`",
            "Values": [
              ":user_extra_id"
            ],
            "Vindex": "user_index"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "mergeable derived table with order by and limit",
    "query": "select 1 from (select col from main.unsharded order by main.unsharded.col1 desc limit 12 offset 0) as f left join unsharded as u on f.col = u.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from (select col from main.unsharded order by main.unsharded.col1 desc limit 12 offset 0) as f left join unsharded as u on f.col = u.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 from (select col from unsharded where 1 != 1) as f left join unsharded as u on f.col = u.id where 1 != 1",
        "Query": "select 1 from (select col from unsharded order by unsharded.col1 desc limit 0, 12) as f left join unsharded as u on f.col = u.id",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "mergeable derived table with group by and limit",
    "query": "select 1 from (select col, count(*) as a from main.unsharded group by col having a > 0 limit 12 offset 0) as f left join unsharded as u on f.col = u.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from (select col, count(*) as a from main.unsharded group by col having a > 0 limit 12 offset 0) as f left join unsharded as u on f.col = u.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 from (select col, count(*) as a from unsharded where 1 != 1 group by col) as f left join unsharded as u on f.col = u.id where 1 != 1",
        "Query": "select 1 from (select col, count(*) as a from unsharded group by col having a > 0 limit 0, 12) as f left join unsharded as u on f.col = u.id",
        "Table": "unsharded"
      },
      "TablesUsed": [
        "main.unsharded"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select user.id, trim(leading 'x' from user.name) from user",
    "query": "select user.id, trim(leading 'x' from user.name) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.id, trim(leading 'x' from user.name) from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.id, trim(leading 'x' from `user`.`name`) from `user` where 1 != 1",
        "Query": "select `user`.id, trim(leading 'x' from `user`.`name`) from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "json utility functions",
    "query": "select jcol, JSON_STORAGE_SIZE(jcol), JSON_STORAGE_FREE(jcol), JSON_PRETTY(jcol) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select jcol, JSON_STORAGE_SIZE(jcol), JSON_STORAGE_FREE(jcol), JSON_PRETTY(jcol) from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select jcol, json_storage_size(jcol), json_storage_free(jcol), json_pretty(jcol) from `user` where 1 != 1",
        "Query": "select jcol, json_storage_size(jcol), json_storage_free(jcol), json_pretty(jcol) from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "dual query with exists clause",
    "query": "select 1 from dual where exists (select 1 from information_schema.TABLES where information_schema.TABLES.TABLE_NAME = 'proc' and information_schema.TABLES.TABLE_SCHEMA = 'mysql')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from dual where exists (select 1 from information_schema.TABLES where information_schema.TABLES.TABLE_NAME = 'proc' and information_schema.TABLES.TABLE_SCHEMA = 'mysql')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "DBA",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 from dual where 1 != 1",
        "Query": "select 1 from dual where exists (select 1 from information_schema.`TABLES` where `TABLES`.TABLE_NAME = :TABLES_TABLE_NAME /* VARCHAR */ and `TABLES`.TABLE_SCHEMA = :__vtschemaname /* VARCHAR */)",
        "SysTableTableName": "[TABLES_TABLE_NAME:'proc']",
        "SysTableTableSchema": "['mysql']",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "json_quote, json_object and json_array",
    "query": "SELECT JSON_QUOTE('null'), JSON_QUOTE('\"null\"'), JSON_OBJECT(BIN(1),2,'abc',ASCII(4)), JSON_ARRAY(1, \"abc\", NULL, TRUE, CURTIME())",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT JSON_QUOTE('null'), JSON_QUOTE('\"null\"'), JSON_OBJECT(BIN(1),2,'abc',ASCII(4)), JSON_ARRAY(1, \"abc\", NULL, TRUE, CURTIME())",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_quote('null'), json_quote('\"null\"'), json_object(BIN(1), 2, 'abc', ASCII(4)), json_array(1, 'abc', null, true, curtime()) from dual where 1 != 1",
        "Query": "select json_quote('null'), json_quote('\"null\"'), json_object(BIN(1), 2, 'abc', ASCII(4)), json_array(1, 'abc', null, true, curtime()) from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "select (select id from user order by id limit 1) from user_extra",
    "query": "select (select id from user order by id limit 1) from user_extra",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select (select id from user order by id limit 1) from user_extra",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutValue",
        "PulloutVars": [
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Limit",
            "Count": "1",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select id, weight_string(id) from `user` where 1 != 1",
                "OrderBy": "(0|1) ASC",
                "Query": "select id, weight_string(id) from `user` order by `user`.id asc limit 1",
                "Table": "`user`"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select :__sq1 as `(select id from ``user`` order by ``user``.id asc limit 1)` from user_extra where 1 != 1",
            "Query": "select :__sq1 as `(select id from ``user`` order by ``user``.id asc limit 1)` from user_extra",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "yeah, it does not make sense, but it's valid",
    "query": "select exists(select 1) from user where id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select exists(select 1) from user where id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select exists (select 1 from dual where 1 != 1) from `user` where 1 != 1",
        "Query": "select exists (select 1 from dual) from `user` where id = 5",
        "Table": "`user`",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "json schema validation functions",
    "query": "SELECT JSON_SCHEMA_VALID('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"'), JSON_SCHEMA_VALIDATION_REPORT('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT JSON_SCHEMA_VALID('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"'), JSON_SCHEMA_VALIDATION_REPORT('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_schema_valid('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"'), json_schema_validation_report('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"') from dual where 1 != 1",
        "Query": "select json_schema_valid('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"'), json_schema_validation_report('{\"type\":\"string\",\"pattern\":\"(\"}', '\"abc\"') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "json search functions",
    "query": "SELECT JSON_CONTAINS('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', '1'), JSON_CONTAINS_PATH('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', 'one', '$.a', '$.e'), JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]'), JSON_UNQUOTE(JSON_EXTRACT('[\"a\",\"b\"]', '$[1]')), JSON_KEYS('{\"a\": 1, \"b\": {\"c\": 30}}'), JSON_OVERLAPS(\"[1,3,5,7]\", \"[2,5,7]\"), JSON_SEARCH('[\"abc\"]', 'one', 'abc'), JSON_VALUE('{\"fname\": \"Joe\", \"lname\": \"Palmer\"}', '$.fname'), JSON_ARRAY(4,5) MEMBER OF('[[3,4],[4,5]]')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT JSON_CONTAINS('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', '1'), JSON_CONTAINS_PATH('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', 'one', '$.a', '$.e'), JSON_EXTRACT('[10, 20, [30, 40]]', '$[1]'), JSON_UNQUOTE(JSON_EXTRACT('[\"a\",\"b\"]', '$[1]')), JSON_KEYS('{\"a\": 1, \"b\": {\"c\": 30}}'), JSON_OVERLAPS(\"[1,3,5,7]\", \"[2,5,7]\"), JSON_SEARCH('[\"abc\"]', 'one', 'abc'), JSON_VALUE('{\"fname\": \"Joe\", \"lname\": \"Palmer\"}', '$.fname'), JSON_ARRAY(4,5) MEMBER OF('[[3,4],[4,5]]')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_contains('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', '1'), json_contains_path('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', 'one', '$.a', '$.e'), json_extract('[10, 20, [30, 40]]', '$[1]'), json_unquote(json_extract('[\"a\",\"b\"]', '$[1]')), json_keys('{\"a\": 1, \"b\": {\"c\": 30}}'), json_overlaps('[1,3,5,7]', '[2,5,7]'), json_search('[\"abc\"]', 'one', 'abc'), json_value('{\"fname\": \"Joe\", \"lname\": \"Palmer\"}', '$.fname'), json_array(4, 5) member of ('[[3,4],[4,5]]') from dual where 1 != 1",
        "Query": "select json_contains('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', '1'), json_contains_path('{\"a\": 1, \"b\": 2, \"c\": {\"d\": 4}}', 'one', '$.a', '$.e'), json_extract('[10, 20, [30, 40]]', '$[1]'), json_unquote(json_extract('[\"a\",\"b\"]', '$[1]')), json_keys('{\"a\": 1, \"b\": {\"c\": 30}}'), json_overlaps('[1,3,5,7]', '[2,5,7]'), json_search('[\"abc\"]', 'one', 'abc'), json_value('{\"fname\": \"Joe\", \"lname\": \"Palmer\"}', '$.fname'), json_array(4, 5) member of ('[[3,4],[4,5]]') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Json extract and json unquote shorthands",
    "query": "SELECT a->\"$[4]\", a->>\"$[3]\" FROM user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT a->\"$[4]\", a->>\"$[3]\" FROM user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select json_extract(a, '$[4]'), json_unquote(json_extract(a, '$[3]')) from `user` where 1 != 1",
        "Query": "select json_extract(a, '$[4]'), json_unquote(json_extract(a, '$[3]')) from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "groupe by with non aggregated columns and table alias",
    "query": "select u.id, u.age from user u group by u.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select u.id, u.age from user u group by u.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select u.id, u.age from `user` as u where 1 != 1 group by u.id",
        "Query": "select u.id, u.age from `user` as u group by u.id",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Functions that return JSON value attributes",
    "query": "select JSON_DEPTH('{}'), JSON_LENGTH('{\"a\": 1, \"b\": {\"c\": 30}}', '$.b'), JSON_TYPE(JSON_EXTRACT('{\"a\": [10, true]}', '$.a')), JSON_VALID('{\"a\": 1}')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select JSON_DEPTH('{}'), JSON_LENGTH('{\"a\": 1, \"b\": {\"c\": 30}}', '$.b'), JSON_TYPE(JSON_EXTRACT('{\"a\": [10, true]}', '$.a')), JSON_VALID('{\"a\": 1}')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_depth('{}'), json_length('{\"a\": 1, \"b\": {\"c\": 30}}', '$.b'), json_type(json_extract('{\"a\": [10, true]}', '$.a')), json_valid('{\"a\": 1}') from dual where 1 != 1",
        "Query": "select json_depth('{}'), json_length('{\"a\": 1, \"b\": {\"c\": 30}}', '$.b'), json_type(json_extract('{\"a\": [10, true]}', '$.a')), json_valid('{\"a\": 1}') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Json array functions",
    "query": "select JSON_ARRAY_APPEND('{\"a\": 1}', '$', 'z'), JSON_ARRAY_INSERT('[\"a\", {\"b\": [1, 2]}, [3, 4]]', '$[0]', 'x', '$[2][1]', 'y'), JSON_INSERT('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', CAST('[true, false]' AS JSON))",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select JSON_ARRAY_APPEND('{\"a\": 1}', '$', 'z'), JSON_ARRAY_INSERT('[\"a\", {\"b\": [1, 2]}, [3, 4]]', '$[0]', 'x', '$[2][1]', 'y'), JSON_INSERT('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', CAST('[true, false]' AS JSON))",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_array_append('{\"a\": 1}', '$', 'z'), json_array_insert('[\"a\", {\"b\": [1, 2]}, [3, 4]]', '$[0]', 'x', '$[2][1]', 'y'), json_insert('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', cast('[true, false]' as JSON)) from dual where 1 != 1",
        "Query": "select json_array_append('{\"a\": 1}', '$', 'z'), json_array_insert('[\"a\", {\"b\": [1, 2]}, [3, 4]]', '$[0]', 'x', '$[2][1]', 'y'), json_insert('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', cast('[true, false]' as JSON)) from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Json merge functions",
    "query": "select JSON_MERGE('[1, 2]', '[true, false]'), JSON_MERGE_PATCH('{\"name\": \"x\"}', '{\"id\": 47}'), JSON_MERGE_PRESERVE('[1, 2]', '{\"id\": 47}')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select JSON_MERGE('[1, 2]', '[true, false]'), JSON_MERGE_PATCH('{\"name\": \"x\"}', '{\"id\": 47}'), JSON_MERGE_PRESERVE('[1, 2]', '{\"id\": 47}')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_merge('[1, 2]', '[true, false]'), json_merge_patch('{\"name\": \"x\"}', '{\"id\": 47}'), json_merge_preserve('[1, 2]', '{\"id\": 47}') from dual where 1 != 1",
        "Query": "select json_merge('[1, 2]', '[true, false]'), json_merge_patch('{\"name\": \"x\"}', '{\"id\": 47}'), json_merge_preserve('[1, 2]', '{\"id\": 47}') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "JSON modifier functions",
    "query": "select JSON_REMOVE('[1, [2, 3], 4]', '$[1]'), JSON_REPLACE('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), JSON_SET('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), JSON_UNQUOTE('\"abc\"')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select JSON_REMOVE('[1, [2, 3], 4]', '$[1]'), JSON_REPLACE('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), JSON_SET('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), JSON_UNQUOTE('\"abc\"')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select json_remove('[1, [2, 3], 4]', '$[1]'), json_replace('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), json_set('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), json_unquote('\"abc\"') from dual where 1 != 1",
        "Query": "select json_remove('[1, [2, 3], 4]', '$[1]'), json_replace('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), json_set('{ \"a\": 1, \"b\": [2, 3]}', '$.a', 10, '$.c', '[true, false]'), json_unquote('\"abc\"') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Reference with a subquery which can be merged",
    "query": "select exists(select id from user where id = 4)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select exists(select id from user where id = 4)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select exists (select 1 from `user` where 1 != 1) from dual where 1 != 1",
        "Query": "select exists (select 1 from `user` where id = 4) from dual",
        "Table": "dual",
        "Values": [
          "4"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "Reference with a subquery which cannot be merged",
    "query": "select exists(select * from user)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select exists(select * from user)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutExists",
        "PulloutVars": [
          "__sq_has_values2",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select 1 from `user` where 1 != 1",
            "Query": "select 1 from `user`",
            "Table": "`user`"
          },
          {
            "InputName": "Outer",
            "OperatorType": "Route",
            "Variant": "Reference",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select :__sq_has_values2 as `exists (select 1 from ``user``)` from dual where 1 != 1",
            "Query": "select :__sq_has_values2 as `exists (select 1 from ``user``)` from dual",
            "Table": "dual"
          }
        ]
      },
      "TablesUsed": [
        "main.dual",
        "user.user"
      ]
    }
  },
  {
    "comment": "insert function not requiring any table",
    "query": "select insert('Quadratic', 3, 4, 'What')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select insert('Quadratic', 3, 4, 'What')",
      "Instructions": {
        "OperatorType": "Projection",
        "Expressions": [
          "'QuWhattic' as insert('Quadratic', 3, 4, 'What')"
        ],
        "Inputs": [
          {
            "OperatorType": "SingleRow"
          }
        ]
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "insert function using column names as arguments",
    "query": "select insert(tcol1, id, 3, tcol2) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select insert(tcol1, id, 3, tcol2) from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select insert(tcol1, id, 3, tcol2) from `user` where 1 != 1",
        "Query": "select insert(tcol1, id, 3, tcol2) from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "gtid functions",
    "query": "select gtid_subset('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'), gtid_subtract('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select gtid_subset('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'), gtid_subtract('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select gtid_subset('3E11FA47-71CA-11E1-9E33-C80AA9429562:23', '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'), gtid_subtract('3E11FA47-71CA-11E1-9E33-C80AA9429562:23', '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57') from dual where 1 != 1",
        "Query": "select gtid_subset('3E11FA47-71CA-11E1-9E33-C80AA9429562:23', '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57'), gtid_subtract('3E11FA47-71CA-11E1-9E33-C80AA9429562:23', '3E11FA47-71CA-11E1-9E33-C80AA9429562:21-57') from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "Predicate in apply join which is merged",
    "query": "select user.col, user_metadata.user_id from user join user_extra on user.col = user_extra.col join user_metadata on user_extra.user_id = user_metadata.user_id where user.textcol1 = 'alice@gmail.com'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.col, user_metadata.user_id from user join user_extra on user.col = user_extra.col join user_metadata on user_extra.user_id = user_metadata.user_id where user.textcol1 = 'alice@gmail.com'",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "JoinVars": {
          "user_col": 0
        },
        "TableName": "`user`_user_extra, user_metadata",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.col from `user` where 1 != 1",
            "Query": "select `user`.col from `user` where `user`.textcol1 = 'alice@gmail.com'",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select user_metadata.user_id from user_extra, user_metadata where 1 != 1",
            "Query": "select user_metadata.user_id from user_extra, user_metadata where user_extra.col = :user_col /* INT16 */ and user_extra.user_id = user_metadata.user_id",
            "Table": "user_extra, user_metadata"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra",
        "user.user_metadata"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Join across multiple tables, with conditions on different vindexes, but mergeable through join predicates",
    "query": "SELECT user.id FROM user INNER JOIN music_extra ON user.id = music_extra.user_id INNER JOIN music ON music_extra.user_id = music.user_id WHERE user.id = 123 and music.id = 456",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT user.id FROM user INNER JOIN music_extra ON user.id = music_extra.user_id INNER JOIN music ON music_extra.user_id = music.user_id WHERE user.id = 123 and music.id = 456",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select `user`.id from `user`, music_extra, music where 1 != 1",
        "Query": "select `user`.id from `user`, music_extra, music where music.id = 456 and `user`.id = 123 and `user`.id = music_extra.user_id and music_extra.user_id = music.user_id",
        "Table": "`user`, music, music_extra",
        "Values": [
          "123"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music",
        "user.music_extra",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "SQL_CALC_FOUND_ROWS with vindex lookup",
    "query": "select SQL_CALC_FOUND_ROWS id, name from user where name = 'aa' order by id limit 2",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select SQL_CALC_FOUND_ROWS id, name from user where name = 'aa' order by id limit 2",
      "Instructions": {
        "OperatorType": "SQL_CALC_FOUND_ROWS",
        "Inputs": [
          {
            "OperatorType": "Limit",
            "Count": "2",
            "Inputs": [
              {
                "OperatorType": "VindexLookup",
                "Variant": "Equal",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "Values": [
                  "'aa'"
                ],
                "Vindex": "name_user_map",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "IN",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                    "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                    "Table": "name_user_vdx",
                    "Values": [
                      "::name"
                    ],
                    "Vindex": "user_index"
                  },
                  {
                    "OperatorType": "Route",
                    "Variant": "ByDestination",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select id, `name`, weight_string(id) from `user` where 1 != 1",
                    "OrderBy": "(0|2) ASC",
                    "Query": "select id, `name`, weight_string(id) from `user` where `name` = 'aa' order by `user`.id asc limit 2",
                    "ResultColumns": 2,
                    "Table": "`user`"
                  }
                ]
              }
            ]
          },
          {
            "OperatorType": "Aggregate",
            "Variant": "Scalar",
            "Aggregates": "sum_count_star(0) AS count(*)",
            "Inputs": [
              {
                "OperatorType": "VindexLookup",
                "Variant": "Equal",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "Values": [
                  "'aa'"
                ],
                "Vindex": "name_user_map",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "IN",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                    "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                    "Table": "name_user_vdx",
                    "Values": [
                      "::name"
                    ],
                    "Vindex": "user_index"
                  },
                  {
                    "OperatorType": "Route",
                    "Variant": "ByDestination",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select count(*) from `user` where 1 != 1",
                    "Query": "select count(*) from `user` where `name` = 'aa'",
                    "Table": "`user`"
                  }
                ]
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "`None` route being merged with another route via join predicate on Vindex columns",
    "query": "SELECT `music`.id FROM `music` INNER JOIN `user` ON music.user_id = user.id WHERE music.user_id IN (NULL) AND user.id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT `music`.id FROM `music` INNER JOIN `user` ON music.user_id = user.id WHERE music.user_id IN (NULL) AND user.id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "None",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music, `user` where 1 != 1",
        "Query": "select music.id from music, `user` where music.user_id in (null) and `user`.id = 5 and music.user_id = `user`.id",
        "Table": "`user`, music"
      },
      "TablesUsed": [
        "user.music",
        "user.user"
      ]
    }
  },
  {
    "comment": "Treating single value tuples as `EqualUnique` routes",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (5)) AND music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (5)) AND music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.user_id = 5 and music.id in (select music.id from music where music.user_id in (5))",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Subquery with `IN` condition using columns with matching lookup vindexes",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3))",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3))",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "IN",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.user_id in (1, 2, 3))",
        "Table": "music",
        "Values": [
          "(1, 2, 3)"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Subquery with `IN` condition using columns with matching lookup vindexes, with derived table",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) _inner)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) _inner)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "IN",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select id from (select music.id from music where music.user_id in (1, 2, 3)) as _inner)",
        "Table": "music",
        "Values": [
          "(1, 2, 3)"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Subquery with `IN` condition using columns with matching lookup vindexes, with inner scatter query",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.foo = 'bar') AND music.user_id IN (3, 4, 5)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.foo = 'bar') AND music.user_id IN (3, 4, 5)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "IN",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.user_id in ::__vals and music.id in (select music.id from music where music.foo = 'bar')",
        "Table": "music",
        "Values": [
          "(3, 4, 5)"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Subquery with `IN` condition using columns with matching lookup vindexes",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) and music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) and music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.user_id = 5 and music.id in (select music.id from music where music.user_id in (1, 2, 3))",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Subquery with `IN` condition using columns with matching lookup vindexes, but not a top level predicate",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) OR music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (1, 2, 3)) OR music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.user_id in (1, 2, 3)) or music.user_id = 5",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "`IN` comparison on Vindex with `None` subquery, as routing predicate",
    "query": "SELECT `music`.id FROM `music` WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) AND music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT `music`.id FROM `music` WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) AND music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "None",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.user_id = 5 and music.id in (select music.id from music where music.user_id in (null))",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "`IN` comparison on Vindex with `None` subquery, as non-routing predicate",
    "query": "SELECT `music`.id FROM `music` WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) OR music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT `music`.id FROM `music` WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) OR music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.user_id in (null)) or music.user_id = 5",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Mergeable scatter subquery",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop')",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop')",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.genre = 'pop')",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Mergeable scatter subquery with `GROUP BY` on unique vindex column",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' GROUP BY music.id)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' GROUP BY music.id)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.genre = 'pop' group by music.id)",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Unmergeable scatter subquery with `GROUP BY` on-non vindex column",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' GROUP BY music.genre)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' GROUP BY music.genre)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Aggregate",
            "Variant": "Ordered",
            "Aggregates": "any_value(0) AS id",
            "GroupBy": "(1|2)",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id, music.genre, weight_string(music.genre) from music where 1 != 1 group by music.genre, weight_string(music.genre)",
                "OrderBy": "(1|2) ASC",
                "Query": "select music.id, music.genre, weight_string(music.genre) from music where music.genre = 'pop' group by music.genre, weight_string(music.genre) order by music.genre asc",
                "Table": "music"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Unmergeable scatter subquery with LIMIT",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' LIMIT 10)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.genre = 'pop' LIMIT 10)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Limit",
            "Count": "10",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where music.genre = 'pop' limit 10",
                "Table": "music"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Mergeable subquery with `MAX` aggregate and grouped by unique vindex",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id IN (5, 6) GROUP BY music.user_id)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id IN (5, 6) GROUP BY music.user_id)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select max(music.id) from music where 1 != 1 group by music.user_id",
            "Query": "select max(music.id) from music where music.user_id in ::__vals group by music.user_id",
            "Table": "music",
            "Values": [
              "(5, 6)"
            ],
            "Vindex": "user_index"
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Unmergeable subquery with `MAX` aggregate",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id IN (5, 6))",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id IN (5, 6))",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Aggregate",
            "Variant": "Scalar",
            "Aggregates": "max(0|1) AS max(music.id)",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select max(music.id), weight_string(max(music.id)) from music where 1 != 1",
                "Query": "select max(music.id), weight_string(max(music.id)) from music where music.user_id in ::__vals",
                "Table": "music",
                "Values": [
                  "(5, 6)"
                ],
                "Vindex": "user_index"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Mergeable subquery with `MAX` aggregate with `EqualUnique` route operator",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id = 5)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id = 5)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select max(music.id) from music where 1 != 1",
            "Query": "select max(music.id) from music where music.user_id = 5",
            "Table": "music",
            "Values": [
              "5"
            ],
            "Vindex": "user_index"
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Mergeable subquery with `LIMIT` due to `EqualUnique` route",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id = 5 LIMIT 10)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT MAX(music.id) FROM music WHERE music.user_id = 5 LIMIT 10)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select max(music.id) from music where 1 != 1",
            "Query": "select max(music.id) from music where music.user_id = 5 limit 10",
            "Table": "music",
            "Values": [
              "5"
            ],
            "Vindex": "user_index"
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Mergeable subquery with multiple levels of derived statements",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id = 5 LIMIT 10) subquery_for_limit) subquery_for_limit)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id = 5 LIMIT 10) subquery_for_limit) subquery_for_limit)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select id from (select id from (select music.id from music where music.user_id = 5 limit 10) as subquery_for_limit) as subquery_for_limit)",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Mergeable subquery with multiple levels of derived statements, using a single value `IN` predicate",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (5) LIMIT 10) subquery_for_limit) subquery_for_limit)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (5) LIMIT 10) subquery_for_limit) subquery_for_limit)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select id from (select id from (select music.id from music where music.user_id in (5) limit 10) as subquery_for_limit) as subquery_for_limit)",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Unmergeable subquery with multiple levels of derived statements, using a multi value `IN` predicate",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (5, 6) LIMIT 10) subquery_for_limit) subquery_for_limit)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music WHERE music.user_id IN (5, 6) LIMIT 10) subquery_for_limit) subquery_for_limit)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Limit",
            "Count": "10",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select id from (select id from (select music.id from music where 1 != 1) as subquery_for_limit where 1 != 1) as subquery_for_limit where 1 != 1",
                "Query": "select id from (select id from (select music.id from music where music.user_id in ::__vals) as subquery_for_limit limit 10) as subquery_for_limit",
                "Table": "music",
                "Values": [
                  "(5, 6)"
                ],
                "Vindex": "user_index"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Unmergeable subquery with multiple levels of derived statements",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music LIMIT 10) subquery_for_limit) subquery_for_limit)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT * FROM (SELECT * FROM (SELECT music.id FROM music LIMIT 10) subquery_for_limit) subquery_for_limit)",
      "Instructions": {
        "OperatorType": "UncorrelatedSubquery",
        "Variant": "PulloutIn",
        "PulloutVars": [
          "__sq_has_values",
          "__sq1"
        ],
        "Inputs": [
          {
            "InputName": "SubQuery",
            "OperatorType": "Limit",
            "Count": "10",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select id from (select id from (select music.id from music where 1 != 1) as subquery_for_limit where 1 != 1) as subquery_for_limit where 1 != 1",
                "Query": "select id from (select id from (select music.id from music) as subquery_for_limit limit 10) as subquery_for_limit",
                "Table": "music"
              }
            ]
          },
          {
            "InputName": "Outer",
            "OperatorType": "VindexLookup",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "Values": [
              "::__sq1"
            ],
            "Vindex": "music_user_map",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "IN",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
                "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
                "Table": "name_user_vdx",
                "Values": [
                  "::name"
                ],
                "Vindex": "user_index"
              },
              {
                "OperatorType": "Route",
                "Variant": "ByDestination",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select music.id from music where 1 != 1",
                "Query": "select music.id from music where :__sq_has_values and music.id in ::__vals",
                "Table": "music"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.music"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "`None` subquery as top level predicate - outer query changes from `Scatter` to `None` on merge",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL))",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL))",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "None",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.user_id in (null))",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "`None` subquery as top level predicate - outer query changes from `EqualUnique` to `None` on merge",
    "query": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) AND music.user_id = 5",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) AND music.user_id = 5",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "None",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.user_id = 5 and music.id in (select music.id from music where music.user_id in (null))",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "`None` subquery nested inside `OR` expression - outer query keeps routing information",
    "query": "SELECT music.id FROM music WHERE (music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) OR music.user_id = 5)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music WHERE (music.id IN (SELECT music.id FROM music WHERE music.user_id IN (NULL)) OR music.user_id = 5)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from music where 1 != 1",
        "Query": "select music.id from music where music.id in (select music.id from music where music.user_id in (null)) or music.user_id = 5",
        "Table": "music"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Joining with a subquery that uses an aggregate column and an `EqualUnique` route can be merged together",
    "query": "SELECT music.id FROM music INNER JOIN (SELECT MAX(id) as maxt FROM music WHERE music.user_id = 5) other ON other.maxt = music.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music INNER JOIN (SELECT MAX(id) as maxt FROM music WHERE music.user_id = 5) other ON other.maxt = music.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from (select max(id) as maxt from music where 1 != 1) as other, music where 1 != 1",
        "Query": "select music.id from (select max(id) as maxt from music where music.user_id = 5) as other, music where other.maxt = music.id",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Joining with a subquery that uses an `EqualUnique` route can be merged",
    "query": "SELECT music.id FROM music INNER JOIN (SELECT id FROM music WHERE music.user_id = 5) other ON other.id = music.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music INNER JOIN (SELECT id FROM music WHERE music.user_id = 5) other ON other.id = music.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from (select id from music where 1 != 1) as other, music where 1 != 1",
        "Query": "select music.id from (select id from music where music.user_id = 5) as other, music where other.id = music.id",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Joining with a subquery that has an `IN` route can be merged",
    "query": "SELECT music.id FROM music INNER JOIN (SELECT id FROM music WHERE music.user_id IN (5, 6, 7)) other ON other.id = music.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM music INNER JOIN (SELECT id FROM music WHERE music.user_id IN (5, 6, 7)) other ON other.id = music.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "IN",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from (select id from music where 1 != 1) as other, music where 1 != 1",
        "Query": "select music.id from (select id from music where music.user_id in ::__vals) as other, music where other.id = music.id",
        "Table": "music",
        "Values": [
          "(5, 6, 7)"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "limit on the vtgate has to be executed on the LHS of a join",
    "query": "select id from user join (select user_id from user_extra limit 10) ue on user.id = ue.user_id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select id from user join (select user_id from user_extra limit 10) ue on user.id = ue.user_id",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0",
        "JoinVars": {
          "ue_user_id": 0
        },
        "TableName": "user_extra_`user`",
        "Inputs": [
          {
            "OperatorType": "Limit",
            "Count": "10",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select ue.user_id from (select user_id from user_extra where 1 != 1) as ue where 1 != 1",
                "Query": "select ue.user_id from (select user_id from user_extra) as ue limit 10",
                "Table": "user_extra"
              }
            ]
          },
          {
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select id from `user` where 1 != 1",
            "Query": "select id from `user` where `user`.id = :ue_user_id",
            "Table": "`user`",
            "Values": [
              ":ue_user_id"
            ],
            "Vindex": "user_index"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "select user.a, t.b from user join (select id, count(*) b, req from user_extra group by req, id) as t on user.id = t.id",
    "query": "select user.a, t.b from user join (select id, count(*) b, req from user_extra group by req, id) as t on user.id = t.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select user.a, t.b from user join (select id, count(*) b, req from user_extra group by req, id) as t on user.id = t.id",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0,L:0",
        "JoinVars": {
          "t_id": 1
        },
        "TableName": "user_extra_`user`",
        "Inputs": [
          {
            "OperatorType": "SimpleProjection",
            "Columns": "1,0",
            "Inputs": [
              {
                "OperatorType": "Aggregate",
                "Variant": "Ordered",
                "Aggregates": "sum_count_star(1) AS b",
                "GroupBy": "(2|3), (0|4)",
                "Inputs": [
                  {
                    "OperatorType": "Route",
                    "Variant": "Scatter",
                    "Keyspace": {
                      "Name": "user",
                      "Sharded": true
                    },
                    "FieldQuery": "select id, count(*) as b, req, weight_string(req), weight_string(id) from user_extra where 1 != 1 group by req, id, weight_string(req), weight_string(id)",
                    "OrderBy": "(2|3) ASC, (0|4) ASC",
                    "Query": "select id, count(*) as b, req, weight_string(req), weight_string(id) from user_extra group by req, id, weight_string(req), weight_string(id) order by req asc, id asc",
                    "Table": "user_extra"
                  }
                ]
              }
            ]
          },
          {
            "OperatorType": "Route",
            "Variant": "EqualUnique",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `user`.a from `user` where 1 != 1",
            "Query": "select `user`.a from `user` where `user`.id = :t_id",
            "Table": "`user`",
            "Values": [
              ":t_id"
            ],
            "Vindex": "user_index"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "SELECT music.id FROM (SELECT MAX(id) as maxt FROM music WHERE music.user_id = 5) other JOIN music ON other.maxt = music.id",
    "query": "SELECT music.id FROM (SELECT MAX(id) as maxt FROM music WHERE music.user_id = 5) other JOIN music ON other.maxt = music.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT music.id FROM (SELECT MAX(id) as maxt FROM music WHERE music.user_id = 5) other JOIN music ON other.maxt = music.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select music.id from (select max(id) as maxt from music where 1 != 1) as other, music where 1 != 1",
        "Query": "select music.id from (select max(id) as maxt from music where music.user_id = 5) as other, music where other.maxt = music.id",
        "Table": "music",
        "Values": [
          "5"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.music"
      ]
    }
  },
  {
    "comment": "Earlier columns are in scope in subqueries https://github.com/vitessio/vitess/issues/11246",
    "query": "SELECT 1 as x, (SELECT x)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT 1 as x, (SELECT x)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Reference",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 as x, (select x from dual where 1 != 1) from dual where 1 != 1",
        "Query": "select 1 as x, (select x from dual) from dual",
        "Table": "dual"
      },
      "TablesUsed": [
        "main.dual"
      ]
    }
  },
  {
    "comment": "(OR 1 = 0) doesn't cause unnecessary scatter",
    "query": "select * from user where id = 1 or 1 = 0",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where id = 1 or 1 = 0",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 1",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "(OR 2 < 1) doesn't cause unnecessary scatter",
    "query": "select * from user where id = 1 or 2 < 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from user where id = 1 or 2 < 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from `user` where 1 != 1",
        "Query": "select * from `user` where id = 1",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "query with a derived table and dual table in unsharded keyspace",
    "query": "SELECT * FROM unsharded_a AS t1  JOIN (SELECT trim((SELECT MAX(name) FROM unsharded_a)) AS name) AS t2 WHERE t1.name >= t2.name ORDER BY t1.name ASC LIMIT 1;",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT * FROM unsharded_a AS t1  JOIN (SELECT trim((SELECT MAX(name) FROM unsharded_a)) AS name) AS t2 WHERE t1.name >= t2.name ORDER BY t1.name ASC LIMIT 1;",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select * from unsharded_a as t1 join (select trim((select max(`name`) from unsharded_a where 1 != 1)) as `name` from dual where 1 != 1) as t2 where 1 != 1",
        "Query": "select * from unsharded_a as t1 join (select trim((select max(`name`) from unsharded_a)) as `name` from dual) as t2 where t1.`name` >= t2.`name` order by t1.`name` asc limit 1",
        "Table": "dual, unsharded_a"
      },
      "TablesUsed": [
        "main.dual",
        "main.unsharded_a"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "subquery having join table on clause, using column reference of outer select table",
    "query": "select (select 1 from user u1 join user u2 on u1.id = u2.id and u1.id = u3.id) subquery from user u3 where u3.id = 1",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select (select 1 from user u1 join user u2 on u1.id = u2.id and u1.id = u3.id) subquery from user u3 where u3.id = 1",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select (select 1 from `user` as u1 join `user` as u2 on u1.id = u2.id and u1.id = u3.id where 1 != 1) as subquery from `user` as u3 where 1 != 1",
        "Query": "select (select 1 from `user` as u1 join `user` as u2 on u1.id = u2.id and u1.id = u3.id) as subquery from `user` as u3 where u3.id = 1",
        "Table": "`user`",
        "Values": [
          "1"
        ],
        "Vindex": "user_index"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "SOME modifier on unsharded table works well",
    "query": "select 1 from unsharded where foo = SOME (select 1 from unsharded_a where foo = 1)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from unsharded where foo = SOME (select 1 from unsharded_a where foo = 1)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 from unsharded where 1 != 1",
        "Query": "select 1 from unsharded where foo = any (select 1 from unsharded_a where foo = 1)",
        "Table": "unsharded, unsharded_a"
      },
      "TablesUsed": [
        "main.unsharded",
        "main.unsharded_a"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "ALL modifier on unsharded table works well",
    "query": "select 1 from unsharded where foo = ALL (select 1 from unsharded_a where foo = 1)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from unsharded where foo = ALL (select 1 from unsharded_a where foo = 1)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select 1 from unsharded where 1 != 1",
        "Query": "select 1 from unsharded where foo = all (select 1 from unsharded_a where foo = 1)",
        "Table": "unsharded, unsharded_a"
      },
      "TablesUsed": [
        "main.unsharded",
        "main.unsharded_a"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "allow last_insert_id with argument",
    "query": "select last_insert_id(id) from user",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select last_insert_id(id) from user",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select last_insert_id(id) from `user` where 1 != 1",
        "Query": "select last_insert_id(id) from `user`",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  },
  {
    "comment": "merge subquery using MAX and join into single route",
    "query": "select 1 from user join music_extra on user.id = music_extra.user_id where music_extra.music_id = (select max(music_id) from music_extra where user_id = user.id)",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from user join music_extra on user.id = music_extra.user_id where music_extra.music_id = (select max(music_id) from music_extra where user_id = user.id)",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select 1 from `user`, music_extra where 1 != 1",
        "Query": "select 1 from `user`, music_extra where `user`.id = music_extra.user_id and music_extra.music_id = (select max(music_id) from music_extra where user_id = `user`.id)",
        "Table": "`user`, music_extra"
      },
      "TablesUsed": [
        "user.music_extra",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Query with non-plannable lookup vindex",
    "query": "SELECT * FROM user_metadata WHERE user_metadata.non_planable = 'foo'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT * FROM user_metadata WHERE user_metadata.non_planable = 'foo'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Equal",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from user_metadata where 1 != 1",
        "Query": "select * from user_metadata where user_metadata.non_planable = 'foo'",
        "Table": "user_metadata",
        "Values": [
          "'foo'"
        ],
        "Vindex": "non_planable_user_map"
      },
      "TablesUsed": [
        "user.user_metadata"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "join query with lookup and join on different vindex column",
    "query": "select u.id from user u, user_metadata um where u.name = 'foo' and u.id = um.user_id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select u.id from user u, user_metadata um where u.name = 'foo' and u.id = um.user_id",
      "Instructions": {
        "OperatorType": "VindexLookup",
        "Variant": "Equal",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "Values": [
          "'foo'"
        ],
        "Vindex": "name_user_map",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select `name`, keyspace_id from name_user_vdx where 1 != 1",
            "Query": "select `name`, keyspace_id from name_user_vdx where `name` in ::__vals",
            "Table": "name_user_vdx",
            "Values": [
              "::name"
            ],
            "Vindex": "user_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "ByDestination",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select u.id from `user` as u, user_metadata as um where 1 != 1",
            "Query": "select u.id from `user` as u, user_metadata as um where u.`name` = 'foo' and u.id = um.user_id",
            "Table": "`user`, user_metadata"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_metadata"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "pick email as vindex lookup",
    "query": "select * from customer where email = 'a@mail.com'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from customer where email = 'a@mail.com'",
      "Instructions": {
        "OperatorType": "VindexLookup",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "Values": [
          "'a@mail.com'"
        ],
        "Vindex": "unq_lkp_vdx",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select unq_key, keyspace_id from unq_lkp_idx where 1 != 1",
            "Query": "select unq_key, keyspace_id from unq_lkp_idx where unq_key in ::__vals",
            "Table": "unq_lkp_idx",
            "Values": [
              "::unq_key"
            ],
            "Vindex": "shard_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "ByDestination",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from customer where 1 != 1",
            "Query": "select * from customer where email = 'a@mail.com'",
            "Table": "customer"
          }
        ]
      },
      "TablesUsed": [
        "user.customer"
      ]
    }
  },
  {
    "comment": "phone is in backfill vindex - not selected for vindex lookup",
    "query": "select * from customer where phone = 123456",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from customer where phone = 123456",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from customer where 1 != 1",
        "Query": "select * from customer where phone = 123456",
        "Table": "customer"
      },
      "TablesUsed": [
        "user.customer"
      ]
    }
  },
  {
    "comment": "name is in backfill vindex - not selected for vindex lookup",
    "query": "select * from customer where name = 'x'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from customer where name = 'x'",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select * from customer where 1 != 1",
        "Query": "select * from customer where `name` = 'x'",
        "Table": "customer"
      },
      "TablesUsed": [
        "user.customer"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "email vindex is costly than phone vindex - but phone vindex is backfiling hence ignored",
    "query": "select * from customer where email = 'a@mail.com' and phone = 123456",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from customer where email = 'a@mail.com' and phone = 123456",
      "Instructions": {
        "OperatorType": "VindexLookup",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "Values": [
          "'a@mail.com'"
        ],
        "Vindex": "unq_lkp_vdx",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select unq_key, keyspace_id from unq_lkp_idx where 1 != 1",
            "Query": "select unq_key, keyspace_id from unq_lkp_idx where unq_key in ::__vals",
            "Table": "unq_lkp_idx",
            "Values": [
              "::unq_key"
            ],
            "Vindex": "shard_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "ByDestination",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from customer where 1 != 1",
            "Query": "select * from customer where email = 'a@mail.com' and phone = 123456",
            "Table": "customer"
          }
        ]
      },
      "TablesUsed": [
        "user.customer"
      ]
    }
  },
  {
    "comment": "predicate order changed: email vindex is costly than phone vindex - but phone vindex is backfiling hence ignored",
    "query": "select * from customer where phone = 123456 and email = 'a@mail.com'",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from customer where phone = 123456 and email = 'a@mail.com'",
      "Instructions": {
        "OperatorType": "VindexLookup",
        "Variant": "EqualUnique",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "Values": [
          "'a@mail.com'"
        ],
        "Vindex": "unq_lkp_vdx",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "IN",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select unq_key, keyspace_id from unq_lkp_idx where 1 != 1",
            "Query": "select unq_key, keyspace_id from unq_lkp_idx where unq_key in ::__vals",
            "Table": "unq_lkp_idx",
            "Values": [
              "::unq_key"
            ],
            "Vindex": "shard_index"
          },
          {
            "OperatorType": "Route",
            "Variant": "ByDestination",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select * from customer where 1 != 1",
            "Query": "select * from customer where phone = 123456 and email = 'a@mail.com'",
            "Table": "customer"
          }
        ]
      },
      "TablesUsed": [
        "user.customer"
      ]
    }
  },
  {
    "comment": "invisible column is not expanded, but valid in predicate",
    "query": "select * from samecolvin where secret = 12",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select * from samecolvin where secret = 12",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select col from samecolvin where 1 != 1",
        "Query": "select col from samecolvin where secret = 12",
        "Table": "samecolvin"
      },
      "TablesUsed": [
        "user.samecolvin"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "column with qualifier is correctly used",
    "query": "select u.foo, ue.foo as apa from user u, user_extra ue order by foo ",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select u.foo, ue.foo as apa from user u, user_extra ue order by foo ",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "L:0,R:0",
        "TableName": "`user`_user_extra",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select u.foo, weight_string(u.foo) from `user` as u where 1 != 1",
            "OrderBy": "(0|1) ASC",
            "Query": "select u.foo, weight_string(u.foo) from `user` as u order by u.foo asc",
            "Table": "`user`"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select ue.foo as apa from user_extra as ue where 1 != 1",
            "Query": "select ue.foo as apa from user_extra as ue",
            "Table": "user_extra"
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Derived tables going to a single shard still need to expand derived table columns",
    "query": "SELECT c.column_name FROM user c JOIN (SELECT table_name FROM unsharded LIMIT 1) AS tables ON tables.table_name = c.table_name",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT c.column_name FROM user c JOIN (SELECT table_name FROM unsharded LIMIT 1) AS tables ON tables.table_name = c.table_name",
      "Instructions": {
        "OperatorType": "Join",
        "Variant": "Join",
        "JoinColumnIndexes": "R:0",
        "JoinVars": {
          "tables_table_name": 0
        },
        "TableName": "unsharded_`user`",
        "Inputs": [
          {
            "OperatorType": "Route",
            "Variant": "Unsharded",
            "Keyspace": {
              "Name": "main",
              "Sharded": false
            },
            "FieldQuery": "select `tables`.table_name from (select table_name from unsharded where 1 != 1) as `tables` where 1 != 1",
            "Query": "select `tables`.table_name from (select table_name from unsharded limit 1) as `tables`",
            "Table": "unsharded"
          },
          {
            "OperatorType": "Route",
            "Variant": "Scatter",
            "Keyspace": {
              "Name": "user",
              "Sharded": true
            },
            "FieldQuery": "select c.column_name from `user` as c where 1 != 1",
            "Query": "select c.column_name from `user` as c where c.table_name = :tables_table_name",
            "Table": "`user`"
          }
        ]
      },
      "TablesUsed": [
        "main.unsharded",
        "user.user"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "column name aliases in outer join queries",
    "query": "select name as t0, name as t1 from user left outer join user_extra on user.cola = user_extra.cola",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select name as t0, name as t1 from user left outer join user_extra on user.cola = user_extra.cola",
      "Instructions": {
        "OperatorType": "SimpleProjection",
        "ColumnNames": [
          "0:t0",
          "1:t1"
        ],
        "Columns": "0,0",
        "Inputs": [
          {
            "OperatorType": "Join",
            "Variant": "LeftJoin",
            "JoinColumnIndexes": "L:0,L:0",
            "JoinVars": {
              "user_cola": 2
            },
            "TableName": "`user`_user_extra",
            "Inputs": [
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select `name` as t0, `name` as t1, `user`.cola from `user` where 1 != 1",
                "Query": "select `name` as t0, `name` as t1, `user`.cola from `user`",
                "Table": "`user`"
              },
              {
                "OperatorType": "Route",
                "Variant": "Scatter",
                "Keyspace": {
                  "Name": "user",
                  "Sharded": true
                },
                "FieldQuery": "select 1 from user_extra where 1 != 1",
                "Query": "select 1 from user_extra where user_extra.cola = :user_cola",
                "Table": "user_extra"
              }
            ]
          }
        ]
      },
      "TablesUsed": [
        "user.user",
        "user.user_extra"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "Over clause works for unsharded tables",
    "query": "SELECT val, CUME_DIST() OVER w, ROW_NUMBER() OVER w, DENSE_RANK() OVER w, PERCENT_RANK() OVER w, RANK() OVER w AS 'cd' FROM unsharded_a",
    "plan": {
      "QueryType": "SELECT",
      "Original": "SELECT val, CUME_DIST() OVER w, ROW_NUMBER() OVER w, DENSE_RANK() OVER w, PERCENT_RANK() OVER w, RANK() OVER w AS 'cd' FROM unsharded_a",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Unsharded",
        "Keyspace": {
          "Name": "main",
          "Sharded": false
        },
        "FieldQuery": "select val, cume_dist() over w, row_number() over w, dense_rank() over w, percent_rank() over w, rank() over w as cd from unsharded_a where 1 != 1",
        "Query": "select val, cume_dist() over w, row_number() over w, dense_rank() over w, percent_rank() over w, rank() over w as cd from unsharded_a",
        "Table": "unsharded_a"
      },
      "TablesUsed": [
        "main.unsharded_a"
      ]
    },
    "skip_e2e": true
  },
  {
    "comment": "join with derived table with alias and join condition - merge into route",
    "query": "select 1 from user join (select id as uid from user) as t where t.uid = user.id",
    "plan": {
      "QueryType": "SELECT",
      "Original": "select 1 from user join (select id as uid from user) as t where t.uid = user.id",
      "Instructions": {
        "OperatorType": "Route",
        "Variant": "Scatter",
        "Keyspace": {
          "Name": "user",
          "Sharded": true
        },
        "FieldQuery": "select 1 from (select id as uid from `user` where 1 != 1) as t, `user` where 1 != 1",
        "Query": "select 1 from (select id as uid from `user`) as t, `user` where t.uid = `user`.id",
        "Table": "`user`"
      },
      "TablesUsed": [
        "user.user"
      ]
    }
  }
]