# LogicTest: 5node

statement ok
CREATE TABLE data (a INT, b INT, c INT, d INT, PRIMARY KEY (a, b, c, d))

# Split into ten parts.
statement ok
ALTER TABLE data SPLIT AT SELECT i FROM generate_series(1, 9) AS g(i)

# Relocate the ten parts to the five nodes.
statement ok
ALTER TABLE data EXPERIMENTAL_RELOCATE
  SELECT ARRAY[i%5+1], i FROM generate_series(0, 9) AS g(i)

# Verify data placement.
query TTTI colnames,rowsort
SELECT start_key, end_key, replicas, lease_holder from [SHOW RANGES FROM TABLE data WITH DETAILS]
ORDER BY 1
----
start_key           end_key       replicas  lease_holder
<before:/Table/72>  …/1/1         {1}       1
…/1/1               …/1/2         {2}       2
…/1/2               …/1/3         {3}       3
…/1/3               …/1/4         {4}       4
…/1/4               …/1/5         {5}       5
…/1/5               …/1/6         {1}       1
…/1/6               …/1/7         {2}       2
…/1/7               …/1/8         {3}       3
…/1/8               …/1/9         {4}       4
…/1/9               <after:/Max>  {5}       5

# ensure merge joins are planned when there's orderings.
query T
EXPLAIN (VERBOSE) (SELECT * FROM (SELECT a,b FROM data) NATURAL JOIN (SELECT a,b FROM data AS data2))
----
distribution: full
vectorized: true
·
• project
│ columns: (a, b)
│
└── • merge join (inner)
    │ columns: (a, b, a, b)
    │ estimated row count: 100 (missing stats)
    │ equality: (a, b) = (a, b)
    │ merge ordering: +"(a=a)",+"(b=b)"
    │
    ├── • scan
    │     columns: (a, b)
    │     ordering: +a,+b
    │     estimated row count: 1,000 (missing stats)
    │     table: data@data_pkey
    │     spans: FULL SCAN
    │
    └── • scan
          columns: (a, b)
          ordering: +a,+b
          estimated row count: 1,000 (missing stats)
          table: data@data_pkey
          spans: FULL SCAN

# TODO(radu): enable these tests when joins pass through orderings on equality
# columns.
#
# # ORDER BY on the mergeJoinOrder columns should not require a SORT node
# query TTTTT
# EXPLAIN (VERBOSE) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY c,d)
# ----
# join                 ·               ·                  (a, b, c, d)                    a=c; b=d; a!=NULL; b!=NULL; +a,+b
#  │                   type            inner              ·                               ·
#  │                   equality        (a, b) = (c, d)    ·                               ·
#  │                   mergeJoinOrder  +"(a=c)",+"(b=d)"  ·                               ·
#  ├── render          ·               ·                  (a, b)                          a!=NULL; b!=NULL; +a,+b
#  │    │              render 0        data1.a            ·                               ·
#  │    │              render 1        data1.b            ·                               ·
#  │    └── scan       ·               ·                  (a, b, c[omitted], d[omitted])  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d); +a,+b
#  │                   table           data@primary       ·                               ·
#  │                   spans           ALL                ·                               ·
#  └── sort            ·               ·                  (c, d)                          c!=NULL; d!=NULL; +c,+d
#       │              order           +c,+d              ·                               ·
#       └── render     ·               ·                  (c, d)                          c!=NULL; d!=NULL
#            │         render 0        data2.c            ·                               ·
#            │         render 1        data2.d            ·                               ·
#            └── scan  ·               ·                  (a[omitted], b[omitted], c, d)  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d)
# ·                    table           data@primary       ·                               ·
# ·                    spans           ALL                ·                               ·
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY c,d)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzElk9v2kwQxu_vp4jm9FbZCu_a_LNUiWsqNanS3ioODt6CJcKitZEaRXz3ChyEbMM-ni6yjwR-3tmZ3-TxO21Mqh-TV51T_IskCVIkKCRBEQka0lzQ1pqFznNjDz8pgYf0D8WBoGyz3RWHP88FLYzVFL9TkRVrTTH9TF7W-lknqbaDgASlukiy9fGYrc1eE_s2S5MiIUFPuyK-m0kxUzTfCzK74uOp54e9vN2tknxVfcwJmQvKi2SpKZZ78W8FDlsUGIpZVCvwfLLinPzD2ELbgQzq97kXM3Xv24TwainnRxmbaqvTq-e3_uWF233Tdqm_mmxzuGKtsWv9u_j_g_70xWbL1fljxQThbnfkf8cLlT-az2Y7UNWxXCthWClBtndN9rIMjAJHt10GcPJpGWQHyyD7XYZRF8ug2g9a9WIio8DxbU0EJ59MVB2YqPo1cdyFiWH7QYe9mMgocHJbE8HJJxPDDkwM-zVx0oWJUftBR72YyChwelsTwcknE6MOTIz6NXHa9avqhYKedb41m1y3egMNDlfS6VKXDcvNzi70d2sWx2PKj09H7vjmk-q8KL8Nyw8Pm_KrQ4Ht4YkPLJUXPfKhVeCmZZ0OKnQFDuqwYjRc8eCJD1xrOJce-dC1hjfo0NnwyD2tyD0t6R7X0Gc_3DDYDzeM9gPQYD_cNNqPkbPjY3fDxz774YbBfrhhtB-ABvvhptF-THz2Y-pjuBsGhrthZDiggeFuGiZAI0AqHZfgn4psJAhHckADywGNNEc48BzgSHTZyBGO6bKRIxzVAQ1cBzSSHeHAdoBD3d0ZKodAd06INmfOSVEuDXVn5SgXh7q7kxTpzolSLo10Z4UpG0e6s-K0ibvzVE6B7pxEbc6cE6lcGurOClUujnRX7lSt6z7f__c3AAD__68_ThQ=
# 
# # ORDER BY on the columns equal to the mergeJoinOrder columns should not
# # require a terminal SORT node.
# query TTTTT
# EXPLAIN (VERBOSE) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY a,b)
# ----
# join                 ·               ·                  (a, b, c, d)                    a=c; b=d; a!=NULL; b!=NULL; +a,+b
#  │                   type            inner              ·                               ·
#  │                   equality        (a, b) = (c, d)    ·                               ·
#  │                   mergeJoinOrder  +"(a=c)",+"(b=d)"  ·                               ·
#  ├── render          ·               ·                  (a, b)                          a!=NULL; b!=NULL; +a,+b
#  │    │              render 0        data1.a            ·                               ·
#  │    │              render 1        data1.b            ·                               ·
#  │    └── scan       ·               ·                  (a, b, c[omitted], d[omitted])  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d); +a,+b
#  │                   table           data@primary       ·                               ·
#  │                   spans           ALL                ·                               ·
#  └── sort            ·               ·                  (c, d)                          c!=NULL; d!=NULL; +c,+d
#       │              order           +c,+d              ·                               ·
#       └── render     ·               ·                  (c, d)                          c!=NULL; d!=NULL
#            │         render 0        data2.c            ·                               ·
#            │         render 1        data2.d            ·                               ·
#            └── scan  ·               ·                  (a[omitted], b[omitted], c, d)  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d)
# ·                    table           data@primary       ·                               ·
# ·                    spans           ALL                ·                               ·
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY a,b)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzElk9v2kwQxu_vp4jm9FbZCu_a_LNUiWsqNanS3ioODt6CJcKitZEaRXz3ChyEbMM-ni6yjwR-3tmZ3-TxO21Mqh-TV51T_IskCVIkKCRBEQka0lzQ1pqFznNjDz8pgYf0D8WBoGyz3RWHP88FLYzVFL9TkRVrTTH9TF7W-lknqbaDgASlukiy9fGYrc1eE_s2S5MiIUFPuyK-m0kxUzTfCzK74uOp54e9vN2tknxVfcwJmQvKi2SpKZZ78W8FDlsUGIpZVCvwfLLinPzD2ELbgQzq97kXM3Xv24TwainnRxmbaqvTq-e3_uWF233Tdqm_mmxzuGKtsWv9u_j_g_70xWbL1fljxQThbnfkf8cLlT-az2Y7UNWxXCthWClBtndN9rIMjAJHt10GcPJpGWQHyyD7XYZRF8ug2g9a9WIio8DxbU0EJ59MVB2YqPo1cdyFiWH7QYe9mMgocHJbE8HJJxPDDkwM-zVx0oWJUftBR72YyChwelsTwcknE6MOTIz6NXHa9avqhYKedb41m1y3egMNDlfS6VKXDcvNzi70d2sWx2PKj09H7vjmk-q8KL8Nyw8Pm_KrQ4Ht4YkPLJUXPfKhVeCmZZ0OKnQFDuqwYjRc8eCJD1xrOJce-dC1hjfo0NnwyD2tyD0t6R7X0Gc_3DDYDzeM9gPQYD_cNNqPkbPjY3fDxz774YbBfrhhtB-ABvvhptF-THz2Y-pjuBsGhrthZDiggeFuGiZAI0AqHZfgn4psJAhHckADywGNNEc48BzgSHTZyBGO6bKRIxzVAQ1cBzSSHeHAdoBD3d0ZKodAd06INmfOSVEuDXVn5SgXh7q7kxTpzolSLo10Z4UpG0e6s-K0ibvzVE6B7pxEbc6cE6lcGurOClUujnRX7lSt6z7f__c3AAD__68_ThQ=

# ORDER BY on a different ordering should require a terminal SORT NODE.
query T
EXPLAIN (VERBOSE) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY b,a)
----
distribution: full
vectorized: true
·
• sort
│ columns: (a, b, c, d)
│ estimated row count: 100 (missing stats)
│ order: +b,+a
│
└── • hash join (inner)
    │ columns: (a, b, c, d)
    │ estimated row count: 100 (missing stats)
    │ equality: (a, b) = (c, d)
    │
    ├── • scan
    │     columns: (a, b)
    │     estimated row count: 1,000 (missing stats)
    │     table: data@data_pkey
    │     spans: FULL SCAN
    │
    └── • scan
          columns: (c, d)
          estimated row count: 1,000 (missing stats)
          table: data@data_pkey
          spans: FULL SCAN

query T
EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d ORDER BY b,a)
----
distribution: full
vectorized: true
·
• sort
│ order: +b,+a
│
└── • hash join
    │ equality: (a, b) = (c, d)
    │
    ├── • scan
    │     missing stats
    │     table: data@data_pkey
    │     spans: FULL SCAN
    │
    └── • scan
          missing stats
          table: data@data_pkey
          spans: FULL SCAN
·
Diagram: https://cockroachdb.github.io/distsqlplan/decode.html#eJy8l99v4kYQx9_7V6zmKfQWwa5tfliKRHqkKqccXCEPrSp0WvAmWEdsahtdo4j_vbIJl9iL5zxOIA9EBvuzOzPfj2w_QfzvGly4_uvLzdVozC6Go9nt7M-bBruYXd9cf7xlv7Lfp5PPPw4VZ4v9N55KFLuaZf9Fg32apJc_n7XkzDPPkmwyHV5P2W9_Zyc02GTMLhS7ZMsGuxoP2cWCXWZfH85acKYawCEIPT1WDzoG9x8QwEECBws42MDBgTmHTRQudRyHUXrKU3bByPsP3DYHP9hsk_TrOYdlGGlwnyDxk7UGF27VYq2nWnk6arWBg6cT5a-zZdIND9KPr5tv-hE4fAzX24cgdrMWAIfZRqVHzZZgKvCYYGGy0hHMdxzCbfK85stSi0e2UvEqv8hA8IGE-W7OIU7UvQZXvKplNAS3veP1ynGqlpOO4mTlyEI5Tmk5L-htEEaejrSXg8_TK392ypGe_KHi1afQD3TUEoURr_VdcpHtuXEZ-ferwwFwmGwTl2VHfGDxgV3ow0uBVqFAQRrYLIySdGOFYQ3kBz4QH0oXtYuLVmnrsY69WunI7sZhM9y0ZLs4h6N7cgp7kvlGiOrJFfVEbIlmS55SRVG3oE49Fd-9oKKMndKCziGjOIOMpJEdZOy8UcZ8W2X1nMiawZfNlnXK4Mu6BXVrBv-9CyoGv1ta0DmCL88QfNLIDsHvvjH4-bZa1XNi1Qy-1WzZpwy-VbegXs3gv3dBxeD3Sgs6R_CtMwSfNLJD8HtvDH6-rXb1nNg1g283W84pg2_XLahfM_jvXVAx-P3Sgs4RfPsMwSeN7BD8_huD36e87Ex1vAmDWFd6nWgXlmqKtMnau9f7ocXhNlrqL1G4zM7dH04yUBZnT8fJ_le5PxgFh5_iJNLq4cfLdXVSt5wkiCghylmSynLKWRaV1S9n2QZLEBovX6McGqlbThJEVKHxOZakspxylkVl9ctZtsGSRVb7NcvKodq5xhsztFCUXR4Hx9iVjaKkKN-WsSunrtKCRsKUJqJQpaksTGkqC1PaYHXqKt2hkTCliShUaSoLU5rKwpQ2WF1Unh6itDHDXm2ljV3163ooaSTMQyIK9ZDKwjyksjAPDZagPNTkotUlojATqSxURTIMc5EMw2Q0YcbNOqeQkIiO5ijxuzXmo7kx43ZdVUiLiMKMpLJQJckwzEkyDJPShBlPOFWl7BFRmJRUFiolGYZJSYZhUpow4zknL2UHkdIcpXHvriyluTHj3l1VSpuIwqSkslApyTBMSjIMk9KEGY87VaXsE1GYlFQWKiUZhklJhmFSmjDjoSf_0tdGpDRGKY17eGUp-7s5h7t1-P2r74EL7ee_5pGPwx-kF6j7GNwnmK3C7xn39nGjY3Dv1DrWHD6rb3qoEx09-IEfJ_4S3CTa6t3ul_8DAAD__6vIYNk=

# TODO(radu): rework these tests (the inner ORDER BY aren't useful anymore).
#
# # Merge joins should be planned for (FULL|LEFT|RIGHT) OUTER joins
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) FULL OUTER JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c and b=d ORDER BY a,b)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzEl0Fv2kAQhe_9FWhOrbJVvGNDwFIlLq2UKA1VmpwqDg7eEiTCorWRGkX57xUQhAxh3zqD8NHBb994Zj6_-IVmNjc32ZMpKP1DmhQxKYpJUUKK2jRUNHd2ZIrCuuUta8Fl_o_SSNFkNl-Uyz8PFY2sM5S-UDkpp4ZSussepubWZLlx5xEpyk2ZTaYrm7mbPGXuuZ9nZUaKBosybfW16jMNXxXZRfl26vawh-fWY1Y8Vo_ZSIaKijIbG0r1q_pYge2AAmPVT3YK3DpzHeff1pXGneto93nOVJ_PpE2ID5ayPcq63DiTH_QPvvOdp_tp3Nhc2cls-Yg7jb17npu09eP--ro1uL_7ftu6GlzekKKp-Vt-fjv1yzc3GT9uLysbovxjSD4wBg4aw9ajLe_vO8Xc2K92fs7Vfh0qoVMpQYfvuW4ExBoFdo4LInDegKhPAKJuFsROkyCGjYGDxnAIRA5fMm6EghoFXhyXAuC8oYBPQAE3S8FFkxSEjYGDxnCIgjh8yeJGKKhRYPe4FADnDQXxCSiIm6Wg2yQFYWPgoDEcoiAJX7KkEQpqFNg7LgXAeUNBcgIKkmYp6DVJQdgYOGgMIZ8m73jcmmJuZ4UJ-uKIlu00-dish1XYhRuZX86OVjbry8FKt_pvLzdFuf41Xl9cztY_LQsMF_ckYp2I1CJvBt56Vx1V1BVxtCvmGg3neuKeRLzT8LpqkTcD79jb8MTf8MQrbvtH3faPuuO37kjg8ovBgvvFCC6gFnkjuC68He_6G96VwOUXgwX3ixFcQC3yRnD1vA3Xkb_jeu9VWgcvvfcqrUMIUIM1BWrECJLL3GEE7b1Qq1OLwdT23qh1QAFqsK1AjVBBcpk7gkX700S3Qd_9eYJoEeUJUKN9lSUKksvcIS3-UNEgVbQoVoAa7assWJBc5g5p8WcLg2xhUbawKFuAGuwrUCNakFzmjmhhf7YwyBYWZQtQo88MWbYgucwd0cL-bGGQLVwvW4avn_4HAAD__9-kdhE=
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) LEFT OUTER JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c and b=d ORDER BY a,b)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzEl0Fv2k4Qxe__T4Hm9K-yVbxjQ8BSJS6plKgNVUpPFQcHbwkSYdHaSI2ifPcKCEKGsG-dQfjo4LdvPDM_v_iF5jY3d9mTKSj9TZoUMSmKSVFCito0UrRwdmyKwrrVLRvBTf6X0kjRdL5Ylqs_jxSNrTOUvlA5LWeGUhpmDzNzb7LcuMuIFOWmzKaztc3CTZ8y99zPszIjRYNlmbb6WvWZRq-K7LJ8O3V32MNz6zErHqvHbCUjRUWZTQyl-lV9rMB2QIGx6id7Be6cuY7zT-tK4y51tP88F6rPF9ImxEdL2R1lXW6cyY_6B9_5ztN9N25ibu10vnrEvcYOnxcmbX27_jpsDX4Nr-9bt4ObO1I0M3_K_99O_fTFTSePu8vKhij_GJIPjIGDxrDzaMv7-04xd_azXVxytV_HSuhUStDhe64bAbFGgZ3TggictyDqM4ComwWx0ySIYWPgoDEcA5HDl4wboaBGgVenpQA4byngM1DAzVJw1SQFYWPgoDEcoyAOX7K4EQpqFNg9LQXAeUtBfAYK4mYp6DZJQdgYOGgMxyhIwpcsaYSCGgX2TksBcN5SkJyBgqRZCnpNUhA2Bg4aQ8inyTse96ZY2Hlhgr44olU7TT4xm2EVdunG5oez47XN5nKw1q3_28tNUW5-jTcXN_PNT6sCw8U9iVgnIrXIm4G33ldHFXVFHO2LuUbDuZ64JxHvNbyuWuTNwDv2NjzxNzzxitv-Ubf9o-74rTsSuPxisOB-MYILqEXeCK4rb8e7_oZ3JXD5xWDB_WIEF1CLvBFcPW_DdeTvuD54ldbBSx-8SusQAtRgTYEaMYLkMncYQQcv1OrUYjC1gzdqHVCAGmwrUCNUkFzmjmDR_jTRbdB3f54gWkR5AtRoX2WJguQyd0iLP1Q0SBUtihWgRvsqCxYkl7lDWvzZwiBbWJQtLMoWoAb7CtSIFiSXuSNa2J8tDLKFRdkC1OgzQ5YtSC5zR7SwP1sYZAvXy5bR63__AgAA__86O3Xp
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b FROM data AS data1) RIGHT OUTER JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c and b=d ORDER BY a,b)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzEl0Fv2kAQhe_9FWhOrbJV2LEhYKkSl6olUkNF6ani4OAtQSIsWhupUZT_XgFByBD2rTMIHx389o1n5vOLn2lhM3OXPpqckj-kSRGToogUxaSoRWNFS2cnJs-tW9-yFfSzf5Q0Fc0Wy1Wx_vNY0cQ6Q8kzFbNibiihUXo_N0OTZsZdN0lRZop0Nt_YLN3sMXVPvSwtUlI0WBVJo6dVj2n8osiuitdT94fdPzUe0vyhfMxOMlaUF-nUUKJf1PsKbAUUGKlefFDg3pmrOP-yrjDuWjcPn-dK9fhK2oToZCn7o6zLjDPZSf_gO994uh_GTc2tnS3Wj3jQ2NHT0iSNYf_b91Fj8Hv0ddi4HfTvSNHc_C0-vh776YubTR_2l6UVUf45xO-YAwfNYe_Rkjf4jWLu7Ge7vOZyw06V0C6VoMMXXddCYoUC2-clETjvSNQXIFHXS2K7VhLD5sBBczhFIodvGdeCQYUCb86LAXDeYcAXwIDrxeCmVgzC5sBBcziFQRS-ZVEtGFQosHNeDIDzDoPoAhhE9WLQqRWDsDlw0BxOYRCHb1lcCwYVCuyeFwPgvMMgvgAGcb0YdGvFIGwOHDSHkM-TNzyGJl_aRW6Cvjqa636abGq208rtyk3MT2cnG5vt5WCj2_zDl5m82P4abS_6i-1P6wLDxV2JWMcitcibgbc-VDdL6pK4eSjmCg3nauKuRHzQ8KpqkTcD78jb8Njf8NgrbvlH3fKPuu23bkvg8ovBgvvFCC6gFnkjuG68He_4G96RwOUXgwX3ixFcQC3yRnB1vQ3XTX_H9dGrtApe-uhVWoUQoAZrCtSIESSXucMIOnqhlqcWgakdvVGrgALUYFuBGqGC5DJ3BIv2p4lugb778wTRIsoToEb7KksUJJe5Q1r8oaJBqmhRrAA12ldZsCC5zB3S4s8WBtnComxhUbYANdhXoEa0ILnMHdHC_mxhkC0syhagRp8ZsmxBcpk7ooX92cIgW7hatoxfPvwPAAD__wYqd4g=
#
#
## Nested merge joins should be planned on the same ordering
# query TTTTT
# EXPLAIN (VERBOSE) (SELECT a,b from data AS data3 NATURAL JOIN ((SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d))
# ----
# render                         ·               ·                                    (a, b)                                                                          a!=NULL; b!=NULL
#  │                             render 0        data3.a                              ·                                                                               ·
#  │                             render 1        data3.b                              ·                                                                               ·
#  └── join                      ·               ·                                    (a, b, c[omitted], d[omitted], a[omitted], b[omitted], c[omitted], d[omitted])  a=c=a=c; b=d=b=d; a!=NULL; b!=NULL
#       │                        type            inner                                ·                                                                               ·
#       │                        equality        (a, b, c, d) = (a, b, c, d)          ·                                                                               ·
#       │                        mergeJoinOrder  +"(a=a)",+"(b=b)",+"(c=c)",+"(d=d)"  ·                                                                               ·
#       ├── scan                 ·               ·                                    (a, b, c, d)                                                                    a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d); +a,+b,+c,+d
#       │                        table           data@primary                         ·                                                                               ·
#       │                        spans           ALL                                  ·                                                                               ·
#       └── join                 ·               ·                                    (a, b, c, d)                                                                    a=c; b=d; a!=NULL; b!=NULL; +a,+b
#            │                   type            inner                                ·                                                                               ·
#            │                   equality        (a, b) = (c, d)                      ·                                                                               ·
#            │                   mergeJoinOrder  +"(a=c)",+"(b=d)"                    ·                                                                               ·
#            ├── render          ·               ·                                    (a, b)                                                                          a!=NULL; b!=NULL; +a,+b
#            │    │              render 0        data1.a                              ·                                                                               ·
#            │    │              render 1        data1.b                              ·                                                                               ·
#            │    └── scan       ·               ·                                    (a, b, c[omitted], d[omitted])                                                  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d); +a,+b
#            │                   table           data@primary                         ·                                                                               ·
#            │                   spans           ALL                                  ·                                                                               ·
#            └── sort            ·               ·                                    (c, d)                                                                          c!=NULL; d!=NULL; +c,+d
#                 │              order           +c,+d                                ·                                                                               ·
#                 └── render     ·               ·                                    (c, d)                                                                          c!=NULL; d!=NULL
#                      │         render 0        data2.c                              ·                                                                               ·
#                      │         render 1        data2.d                              ·                                                                               ·
#                      └── scan  ·               ·                                    (a[omitted], b[omitted], c, d)                                                  a!=NULL; b!=NULL; c!=NULL; d!=NULL; key(a,b,c,d)
# ·                              table           data@primary                         ·                                                                               ·
# ·                              spans           ALL                                  ·                                                                               ·
# 
# query T
# EXPLAIN (DISTSQL) (SELECT * FROM (SELECT a,b from data AS data3 NATURAL JOIN ((SELECT a,b FROM data AS data1) JOIN (SELECT c,d FROM data AS data2 ORDER BY c,d) ON a=c AND b=d)))
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJzMmE1v2kwQx-_Pp4jm9FTZKt61eZUq-ZpKTaq0t4qDg7cEiWBkG6lRxHevgFBiL5m_xxY2R15-zOxk9-d_9pWWSWzvomeb0fgXaVJkSJFPigJS1KOJolWaTG2WJen2K3vgNv5DY0_RfLla59u3J4qmSWpp_Er5PF9YGtPP6HFhH2wU2_TGI0WxzaP5Yldmlc6fo_QljKM8oslGUbLO337oyD--XD1F2VORDLUKjQp9FQY02UwUZXk0szTWG1Wvsx7TmaL7dT6-2tWs0WahQVO3Qc3N7tDh2zzed3gs7UtK_0jSfFu1V17QtQrNddMpBB-2cvypJI1tauMP61f-5onVfbPpzH5N5kub3pjSYBf2d_7_G_3pSzqfPR1fFraCOjXumvu213AgKvSvVRgIBvOOQAPqfTygw6-UBvXvbe7sHFffr7D69fLUak42f5d8TlY3vlf65unag0JtLTiQ7bpM0Fm_E5dJRsfNrobLQOmDy_otuEx36zJ9cS6TD-SsLuu36zJT_VCYdn0i6GzQiU8EDWpudjV8AkoffDJowSemW5-Yi_OJfCBn9cmgXZ_41Q-F365PBJ0NO_GJoEHNza6GT0Dpg0-GLfjE79Yn_sX5RD6Qs_pk2K5PguqHImjXJ4LORp34RNCg5mZXwyeg9MEnoxZ8EnTrk-DifCIfyFl9Muru7uZEaw82WyXLzFa6mfG2i7PxzO5HmSXrdGq_p8l0V2b_8n7H7f7LjG2W7z_t7V_cLvcfbRusDmvTiB42oU3QhPY9ntYsDUrzsNaN6EET2viN6BFPmzLtFUZegL0y7AsmbmRwaeJSetCELk1cSo94OhCcbSFcOttSetiENuDPzdOls-3QPXab9vk93uf3uOY3-aCJi3kYuRjQwMU8jVzM08jFwyYu5mHkYkADF_M0cjGggYtH7D7VHr9PNf_0BMcT0EjHCAc-BjgSMsKBkTX_CAVKBjRyMsKBlAGOrAxwpGXNxwfgZc0_SIFaAY3cinAgV4AjuwIcRl3-aYqKgxyAwi7AUdoFOQLFXYADx2o-Seg-kKyTJUSS5WkoWYAjyfI4lCzAkWQlOUpKQ8mKkpQUh5IVZSkXd1KFSLJOqhBJlqehZAGOJMvjULI8jiRrJIFKSiPJIhxIFuBIsghHlwpOqijsWGN4yRonVUgkC2gkWYQDyQIcSRbhQLJGkqikNJIswoFkAY4kC3AkWePEColkjZMqJJIFNJIswoFkAY4kC3AoWUmgktJQsqJAJcWhZEWBysWdVFGU7BBIVnJF4x4X0R2NGEeSFd3SiHEkWUmiktJQsqJEJcWhZEWJyr04d2IFK9nJ5r-_AQAA__9IVxsL
# 
# 
# statement ok
# CREATE TABLE distsql_mj_test (k INT, v INT)
# 
# query T
# EXPLAIN (DISTSQL) (SELECT l.k, r.k FROM (SELECT * FROM distsql_mj_test ORDER BY k) l INNER JOIN (SELECT * FROM distsql_mj_test ORDER BY k) r ON l.k = r.k)
# ----
# https://cockroachdb.github.io/distsqlplan/decode.html#eJyskk9Lw0AQxe9-CpmT0pVk06SHgJBrBVup3qSUmB3jSpqNsxtQSr-7JHtIE8z2D952Z-f35r1ldlAqgYt0ixriV-DAIII1g4pUhlorasq2aS6-IfYZyLKqTVNeM8gUIcQ7MNIUCDEs1J2qvAgYCDSpLNq2PQNVmw7SJs0R4tmeHQhzt_BL-lbgClOB5Pk9eahIblP6SYTURn8Vm-3nxqA2wGBZm_g64TDmgJ_j4FmRQfJ4f3jCJ6PywaUBg_8KOL0g4PT0gOGofKdal4oEEorhThxv-cPjI1KOD0qWSF7YN1rgu7lJ-OT2nmT-YY_dF7EkGI0R9WIc2fAV6kqVGk9acb_JgCJH-yda1ZThE6msHWOvy5ZrCwK1sa8ze5mX9qkxeAhzJxy44cAJRz2YD-GpEw7dk8MzJgdDOHLC_mDyen_1GwAA___yFZqv

# Regression test for incorrectly populating PlanToStreamColMap for the right
# side of merge joins (#51883).
statement ok
CREATE TABLE customer (c_custkey INT8 PRIMARY KEY);
CREATE TABLE orders (
  o_orderkey INT8 PRIMARY KEY, o_custkey INT8 NOT NULL,
  CONSTRAINT orders_fkey_customer FOREIGN KEY (o_custkey) REFERENCES customer (c_custkey)
);
CREATE TABLE lineitem (
  l_orderkey INT8 NOT NULL,
  l_linenumber INT8 NOT NULL,
  l_quantity FLOAT8 NOT NULL,
  PRIMARY KEY (l_orderkey, l_linenumber),
  CONSTRAINT lineitem_fkey_orders FOREIGN KEY (l_orderkey) REFERENCES orders (o_orderkey)
);
ALTER TABLE lineitem SPLIT AT SELECT i FROM generate_series(1, 9) AS g(i);
ALTER TABLE lineitem EXPERIMENTAL_RELOCATE SELECT ARRAY[i%5+1], i FROM generate_series(0, 9) AS g(i)

# This query checks that there is no type mismatch during the vectorized flow
# setup which would occur if the stream column indices got messed up.
statement ok
SET vectorize=on;
EXPLAIN (VEC)
  SELECT
    sum(l_quantity)
  FROM
    customer,
    orders
    INNER MERGE JOIN lineitem ON o_orderkey = l_orderkey
  WHERE
    o_orderkey
    IN (
        SELECT
          l_orderkey
        FROM
          lineitem
        GROUP BY
          l_orderkey
        HAVING
          sum(l_quantity) > 300
      )
    AND c_custkey = o_custkey;
RESET vectorize

statement ok
CREATE TABLE kv (k INT PRIMARY KEY, v INT, FAMILY (k, v));
ALTER TABLE kv SPLIT AT SELECT i FROM generate_series(1,5) AS g(i);
ALTER TABLE kv EXPERIMENTAL_RELOCATE SELECT ARRAY[i], i FROM generate_series(1, 5) as g(i);

statement ok
ALTER TABLE kv INJECT STATISTICS '[
  {
    "columns": ["k"],
    "created_at": "2024-01-01 1:00:00.00000+00:00",
    "row_count": 1000,
    "distinct_count": 1000
  }
]';

# Force the distribution of the next plan.
statement ok
SET distribute_scan_row_count_threshold = 1;

# Verify that when merging plans where each has a single result router (n3 and
# n4), we plan the joiner on the same node as the right input (n4).
query T
SELECT * FROM [EXPLAIN (DISTSQL) SELECT * FROM kv AS t1, kv AS t2 WHERE t1.k = 3 AND t2.k = 4] WHERE info LIKE 'Diagram%';
----
Diagram: https://cockroachdb.github.io/distsqlplan/decode.html#eJycklFv2jAUhd_3K6wrTYXJjDjJk6VJoJKp2Sh0BGmTKlR55EKthDizHboK8d-nhLKSqKTd_BDl2sffPcf2DsyvFDhEwTi4nJMP5PNsek1ugx8342E4IZ1RGM2jb-MuqQuSLRlGxDJ6_HPJ96tgFpCOZR8T8ol4XTKcjEjHulXpdxdPApmtFBmHXwNyMZJircXm_QVQyFSME7FBA_wWGFDwgIIPCwq5Vks0RulyaVcJw_g3cIeCzPLCltMLCkulEfgOrLQpAoeJ6qm8X1JitEKmlWxPQRX2eZOxYo3A_ZMu4Qi4t6cnjVh7o7n4meIMRYy679TaQbIdJNu7PMFHoHCp0mKTGU4SSrZAIcpFWfW9vgPnjLGGMadmzH27MfYfxvwWY27DGDtr7NlPkSkdo8a4eSevS15IdyXM_RclM9R9tx5uWlhOBowOXDrw6MA_G8JrhHBrIV55XzM0ucoMvumBOY1OPVZGwniNhyMyqtBLvNFqWWkP5bQCVRMxGntY9Q9FmB2XjNUoNn8fxymJtZK8Gom1ktx_ILmnJNYkea0k53w6tzyxVaoe7mQMHJyn0XvhcxxQbhBrU15bdK8eKuz8MS8PfSVSgxSuRYIjtKg3MpPGyiVwqwvc79_9CQAA__-phZ3F

statement ok
RESET distribute_scan_row_count_threshold;
