diff --git a/src/backend/distributed/planner/multi_logical_planner.c b/src/backend/distributed/planner/multi_logical_planner.c
index ebc71e2a691..662d4050312 100644
--- a/src/backend/distributed/planner/multi_logical_planner.c
+++ b/src/backend/distributed/planner/multi_logical_planner.c
@@ -1170,7 +1170,8 @@ HasComplexRangeTableType(Query *queryTree)
 		if (rangeTableEntry->rtekind != RTE_RELATION &&
 			rangeTableEntry->rtekind != RTE_SUBQUERY &&
 			rangeTableEntry->rtekind != RTE_FUNCTION &&
-			rangeTableEntry->rtekind != RTE_VALUES)
+			rangeTableEntry->rtekind != RTE_VALUES &&
+			!IsJsonTableRTE(rangeTableEntry))
 		{
 			hasComplexRangeTableType = true;
 		}
diff --git a/src/backend/distributed/planner/query_pushdown_planning.c b/src/backend/distributed/planner/query_pushdown_planning.c
index 65de8680ccb..fe89284c0b8 100644
--- a/src/backend/distributed/planner/query_pushdown_planning.c
+++ b/src/backend/distributed/planner/query_pushdown_planning.c
@@ -61,7 +61,8 @@ typedef enum RecurringTuplesType
 	RECURRING_TUPLES_FUNCTION,
 	RECURRING_TUPLES_EMPTY_JOIN_TREE,
 	RECURRING_TUPLES_RESULT_FUNCTION,
-	RECURRING_TUPLES_VALUES
+	RECURRING_TUPLES_VALUES,
+	RECURRING_TUPLES_JSON_TABLE
 } RecurringTuplesType;
 
 /*
@@ -347,7 +348,8 @@ IsFunctionOrValuesRTE(Node *node)
 		RangeTblEntry *rangeTblEntry = (RangeTblEntry *) node;
 
 		if (rangeTblEntry->rtekind == RTE_FUNCTION ||
-			rangeTblEntry->rtekind == RTE_VALUES)
+			rangeTblEntry->rtekind == RTE_VALUES ||
+			IsJsonTableRTE(rangeTblEntry))
 		{
 			return true;
 		}
@@ -700,6 +702,13 @@ DeferErrorIfFromClauseRecurs(Query *queryTree)
 							 "the FROM clause contains VALUES", NULL,
 							 NULL);
 	}
+	else if (recurType == RECURRING_TUPLES_JSON_TABLE)
+	{
+		return DeferredError(ERRCODE_FEATURE_NOT_SUPPORTED,
+							 "correlated subqueries are not supported when "
+							 "the FROM clause contains JSON_TABLE", NULL,
+							 NULL);
+	}
 
 
 	/*
@@ -1204,7 +1213,8 @@ DeferErrorIfUnsupportedTableCombination(Query *queryTree)
 		 */
 		if (rangeTableEntry->rtekind == RTE_RELATION ||
 			rangeTableEntry->rtekind == RTE_SUBQUERY ||
-			rangeTableEntry->rtekind == RTE_RESULT)
+			rangeTableEntry->rtekind == RTE_RESULT ||
+			IsJsonTableRTE(rangeTableEntry))
 		{
 			/* accepted */
 		}
@@ -1372,6 +1382,13 @@ DeferErrorIfUnsupportedUnionQuery(Query *subqueryTree)
 							 "VALUES is not supported within a "
 							 "UNION", NULL);
 	}
+	else if (recurType == RECURRING_TUPLES_JSON_TABLE)
+	{
+		return DeferredError(ERRCODE_FEATURE_NOT_SUPPORTED,
+							 "cannot push down this subquery",
+							 "JSON_TABLE is not supported within a "
+							 "UNION", NULL);
+	}
 
 	return NULL;
 }
@@ -1477,6 +1494,11 @@ RecurringTypeDescription(RecurringTuplesType recurType)
 			return "a VALUES clause";
 		}
 
+		case RECURRING_TUPLES_JSON_TABLE:
+		{
+			return "a JSON_TABLE";
+		}
+
 		case RECURRING_TUPLES_INVALID:
 		{
 			/*
@@ -1673,7 +1695,8 @@ DeferredErrorIfUnsupportedLateralSubquery(PlannerInfo *plannerInfo,
 				 * strings anyway.
 				 */
 				if (recurType != RECURRING_TUPLES_VALUES &&
-					recurType != RECURRING_TUPLES_RESULT_FUNCTION)
+					recurType != RECURRING_TUPLES_RESULT_FUNCTION &&
+					recurType != RECURRING_TUPLES_JSON_TABLE)
 				{
 					recurTypeDescription = psprintf("%s (%s)", recurTypeDescription,
 													recurringRangeTableEntry->eref->
@@ -1750,6 +1773,26 @@ ContainsRecurringRangeTable(List *rangeTable, RecurringTuplesType *recurType)
 }
 
 
+/*
+ * IsJsonTableRTE checks whether the RTE refers to a JSON_TABLE
+ * table function, which was introduced in PostgreSQL 15.
+ */
+bool
+IsJsonTableRTE(RangeTblEntry *rte)
+{
+#if PG_VERSION_NUM >= PG_VERSION_17
+	if (rte == NULL)
+	{
+		return false;
+	}
+	return (rte->rtekind == RTE_TABLEFUNC &&
+			rte->tablefunc->functype == TFT_JSON_TABLE);
+#endif
+
+	return false;
+}
+
+
 /*
  * HasRecurringTuples returns whether any part of the expression will generate
  * the same set of tuples in every query on shards when executing a distributed
@@ -1811,6 +1854,11 @@ HasRecurringTuples(Node *node, RecurringTuplesType *recurType)
 			*recurType = RECURRING_TUPLES_VALUES;
 			return true;
 		}
+		else if (IsJsonTableRTE(rangeTableEntry))
+		{
+			*recurType = RECURRING_TUPLES_JSON_TABLE;
+			return true;
+		}
 
 		return false;
 	}
diff --git a/src/include/distributed/query_pushdown_planning.h b/src/include/distributed/query_pushdown_planning.h
index e0d4f25ddc5..47a34cee072 100644
--- a/src/include/distributed/query_pushdown_planning.h
+++ b/src/include/distributed/query_pushdown_planning.h
@@ -46,6 +46,7 @@ extern DeferredErrorMessage * DeferErrorIfCannotPushdownSubquery(Query *subquery
 																 bool
 																 outerMostQueryHasLimit);
 extern DeferredErrorMessage * DeferErrorIfUnsupportedUnionQuery(Query *queryTree);
+extern bool IsJsonTableRTE(RangeTblEntry *rte);
 
 
 #endif /* QUERY_PUSHDOWN_PLANNING_H */
diff --git a/src/test/regress/expected/json_table.out b/src/test/regress/expected/json_table.out
new file mode 100644
index 00000000000..7bc91026987
--- /dev/null
+++ b/src/test/regress/expected/json_table.out
@@ -0,0 +1,562 @@
+--
+-- JSON_TABLE
+-- PG17 has added basic JSON_TABLE() functionality
+-- JSON_TABLE() allows JSON data to be converted into a relational view
+-- and thus used, for example, in a FROM clause, like other tabular
+-- data. We treat JSON_TABLE the same as correlated functions (e.g., recurring tuples).
+-- In the end, for multi-shard JSON_TABLE commands, we apply the same
+-- restrictions as reference tables (e.g., cannot perform a lateral outer join
+-- when a distributed subquery references a (reference table)/JSON_TABLE etc.)
+-- Relevant PG commit:
+-- https://github.com/postgres/postgres/commit/de3600452
+--
+SHOW server_version \gset
+SELECT substring(:'server_version', '\d+')::int >= 17 AS server_version_ge_17
+\gset
+\if :server_version_ge_17
+\else
+\q
+\endif
+CREATE SCHEMA json_table;
+SET search_path TO json_table;
+SET citus.next_shard_id TO 1687000;
+CREATE TABLE test_table(id bigserial, value text);
+SELECT create_distributed_table('test_table', 'id');
+ create_distributed_table
+---------------------------------------------------------------------
+
+(1 row)
+
+INSERT INTO test_table (value) SELECT i::text FROM generate_series(0,100)i;
+CREATE TABLE my_films(id bigserial, js jsonb);
+SELECT create_distributed_table('my_films', 'id');
+ create_distributed_table
+---------------------------------------------------------------------
+
+(1 row)
+
+INSERT INTO my_films(js) VALUES (
+'{ "favorites" : [
+   { "kind" : "comedy", "films" : [ { "title" : "Bananas", "director" : "Woody Allen"},
+                                    { "title" : "The Dinner Game", "director" : "Francis Veber" } ] },
+   { "kind" : "horror", "films" : [{ "title" : "Psycho", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "thriller", "films" : [{ "title" : "Vertigo", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "drama", "films" : [{ "title" : "Yojimbo", "director" : "Akira Kurosawa" } ] }
+  ] }');
+INSERT INTO my_films(js) VALUES (
+'{ "favorites" : [
+   { "kind" : "comedy", "films" : [ { "title" : "Bananas2", "director" : "Woody Allen"},
+                                    { "title" : "The Dinner Game2", "director" : "Francis Veber" } ] },
+   { "kind" : "horror", "films" : [{ "title" : "Psycho2", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "thriller", "films" : [{ "title" : "Vertigo2", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "drama", "films" : [{ "title" : "Yojimbo2", "director" : "Akira Kurosawa" } ] }
+  ] }');
+-- a router query
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+      WHERE my_films.id = 1
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title      |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas         | Woody Allen
+  1 | comedy   | The Dinner Game | Francis Veber
+  2 | horror   | Psycho          | Alfred Hitchcock
+  3 | thriller | Vertigo         | Alfred Hitchcock
+  4 | drama    | Yojimbo         | Akira Kurosawa
+(5 rows)
+
+-- router query with an explicit LATEREL SUBQUERY
+SELECT sub.*
+FROM my_films,
+     lateral(SELECT * FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                           kind text PATH '$.kind',
+                           NESTED PATH '$.films[*]' COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt) as sub
+WHERE my_films.id = 1;
+ id |   kind   |      title      |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas         | Woody Allen
+  1 | comedy   | The Dinner Game | Francis Veber
+  2 | horror   | Psycho          | Alfred Hitchcock
+  3 | thriller | Vertigo         | Alfred Hitchcock
+  4 | drama    | Yojimbo         | Akira Kurosawa
+(5 rows)
+
+-- router query with an explicit LATEREL SUBQUERY and LIMIT
+SELECT sub.*
+FROM my_films,
+     lateral(SELECT * FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                           kind text PATH '$.kind',
+                           NESTED PATH '$.films[*]' COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt ORDER BY id DESC LIMIT 1) as sub
+WHERE my_films.id = 1;
+ id | kind  |  title  |    director
+---------------------------------------------------------------------
+  4 | drama | Yojimbo | Akira Kurosawa
+(1 row)
+
+-- set it DEBUG1 in case the plan changes
+-- we can see details
+SET client_min_messages TO DEBUG1;
+-- a mult-shard query
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title       |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas          | Woody Allen
+  1 | comedy   | Bananas2         | Woody Allen
+  1 | comedy   | The Dinner Game  | Francis Veber
+  1 | comedy   | The Dinner Game2 | Francis Veber
+  2 | horror   | Psycho           | Alfred Hitchcock
+  2 | horror   | Psycho2          | Alfred Hitchcock
+  3 | thriller | Vertigo          | Alfred Hitchcock
+  3 | thriller | Vertigo2         | Alfred Hitchcock
+  4 | drama    | Yojimbo          | Akira Kurosawa
+  4 | drama    | Yojimbo2         | Akira Kurosawa
+(10 rows)
+
+-- recursively plan subqueries that has JSON_TABLE
+SELECT count(*) FROM
+(
+ SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+    LIMIT 1) as sub_with_json, test_table
+WHERE test_table.id = sub_with_json.id;
+DEBUG:  push down of limit count: 1
+DEBUG:  generating subplan XXX_1 for subquery SELECT jt.id, jt.kind, jt.title, jt.director FROM "json_table".my_films, LATERAL JSON_TABLE(my_films.js, '$."favorites"[*]' AS json_table_path_0 COLUMNS (id FOR ORDINALITY, kind text PATH '$."kind"', NESTED PATH '$."films"[*]' AS json_table_path_1 COLUMNS (title text PATH '$."title"', director text PATH '$."director"'))) jt LIMIT 1
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT count(*) AS count FROM (SELECT intermediate_result.id, intermediate_result.kind, intermediate_result.title, intermediate_result.director FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(id integer, kind text, title text, director text)) sub_with_json, "json_table".test_table WHERE (test_table.id OPERATOR(pg_catalog.=) sub_with_json.id)
+ count
+---------------------------------------------------------------------
+     1
+(1 row)
+
+-- multi-shard query with an explicit LATEREL SUBQUERY
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+   												  kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true)
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title       |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas          | Woody Allen
+  1 | comedy   | Bananas2         | Woody Allen
+  1 | comedy   | The Dinner Game  | Francis Veber
+  1 | comedy   | The Dinner Game2 | Francis Veber
+  2 | horror   | Psycho           | Alfred Hitchcock
+  2 | horror   | Psycho2          | Alfred Hitchcock
+  3 | thriller | Vertigo          | Alfred Hitchcock
+  3 | thriller | Vertigo2         | Alfred Hitchcock
+  4 | drama    | Yojimbo          | Akira Kurosawa
+  4 | drama    | Yojimbo2         | Akira Kurosawa
+(10 rows)
+
+-- JSON_TABLE can be on the inner part of an outer joion
+SELECT sub.*
+FROM my_films LEFT JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true)
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title       |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas          | Woody Allen
+  1 | comedy   | Bananas2         | Woody Allen
+  1 | comedy   | The Dinner Game  | Francis Veber
+  1 | comedy   | The Dinner Game2 | Francis Veber
+  2 | horror   | Psycho           | Alfred Hitchcock
+  2 | horror   | Psycho2          | Alfred Hitchcock
+  3 | thriller | Vertigo          | Alfred Hitchcock
+  3 | thriller | Vertigo2         | Alfred Hitchcock
+  4 | drama    | Yojimbo          | Akira Kurosawa
+  4 | drama    | Yojimbo2         | Akira Kurosawa
+(10 rows)
+
+-- we can pushdown this correlated subquery in WHERE clause
+SELECT count(*)
+FROM my_films WHERE
+  (SELECT count(*) > 0
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000);
+ count
+---------------------------------------------------------------------
+     2
+(1 row)
+
+-- we can pushdown this correlated subquery in SELECT clause
+ SELECT (SELECT count(*) > 0
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt)
+FROM my_films;
+ ?column?
+---------------------------------------------------------------------
+ t
+ t
+(2 rows)
+
+-- multi-shard query with an explicit LATEREL SUBQUERY
+-- along with other tables
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) JOIN test_table ON(my_films.id = test_table.id)
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title       |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas          | Woody Allen
+  1 | comedy   | Bananas2         | Woody Allen
+  1 | comedy   | The Dinner Game  | Francis Veber
+  1 | comedy   | The Dinner Game2 | Francis Veber
+  2 | horror   | Psycho           | Alfred Hitchcock
+  2 | horror   | Psycho2          | Alfred Hitchcock
+  3 | thriller | Vertigo          | Alfred Hitchcock
+  3 | thriller | Vertigo2         | Alfred Hitchcock
+  4 | drama    | Yojimbo          | Akira Kurosawa
+  4 | drama    | Yojimbo2         | Akira Kurosawa
+(10 rows)
+
+-- non-colocated join fails
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) JOIN test_table ON(my_films.id != test_table.id)
+    ORDER BY 1,2,3,4;
+ERROR:  complex joins are only supported when all distributed tables are co-located and joined on their distribution columns
+-- JSON_TABLE can be in the outer part of the join
+-- as long as there is a distributed table
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) LEFT JOIN test_table ON(my_films.id = test_table.id)
+    ORDER BY 1,2,3,4;
+ id |   kind   |      title       |     director
+---------------------------------------------------------------------
+  1 | comedy   | Bananas          | Woody Allen
+  1 | comedy   | Bananas2         | Woody Allen
+  1 | comedy   | The Dinner Game  | Francis Veber
+  1 | comedy   | The Dinner Game2 | Francis Veber
+  2 | horror   | Psycho           | Alfred Hitchcock
+  2 | horror   | Psycho2          | Alfred Hitchcock
+  3 | thriller | Vertigo          | Alfred Hitchcock
+  3 | thriller | Vertigo2         | Alfred Hitchcock
+  4 | drama    | Yojimbo          | Akira Kurosawa
+  4 | drama    | Yojimbo2         | Akira Kurosawa
+(10 rows)
+
+-- JSON_TABLE can be on the outer side of the join
+-- We support outer joins where the outer rel is a recurring one
+-- and the inner one is a non-recurring one if we don't reference the outer from the inner
+-- https://github.com/citusdata/citus/pull/6512
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+LEFT JOIN LATERAL
+  (SELECT *
+   FROM my_films) AS foo on(foo.id = a);
+DEBUG:  recursively planning right side of the left join since the outer side is a recurring rel
+DEBUG:  recursively planning the distributed subquery since it is part of a distributed join node that is outer joined with a recurring rel
+DEBUG:  generating subplan XXX_1 for subquery SELECT id, js FROM "json_table".my_films
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT "json_table".id, "json_table".column_a, "json_table".column_b, "json_table".a, "json_table".b, "json_table".c, foo.id, foo.js FROM (JSON_TABLE('[{"a": 10, "b": 20}, {"a": 30, "b": 40}]'::jsonb, '$[*]' AS json_table_path_0 COLUMNS (id FOR ORDINALITY, column_a integer PATH '$."a"', column_b integer PATH '$."b"', a integer PATH '$."a"', b integer PATH '$."b"', c text PATH '$."c"')) LEFT JOIN LATERAL (SELECT intermediate_result.id, intermediate_result.js FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(id bigint, js jsonb)) foo ON ((foo.id OPERATOR(pg_catalog.=) "json_table".a)))
+ id | column_a | column_b | a  | b  | c | id | js
+---------------------------------------------------------------------
+  1 |       10 |       20 | 10 | 20 |   |    |
+  2 |       30 |       40 | 30 | 40 |   |    |
+(2 rows)
+
+-- However we don't support
+-- when we reference the JSON_TABLE from the non-recurring distributed table subquery
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (json_id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+LEFT JOIN LATERAL
+  (SELECT *
+   FROM my_films WHERE id::text LIKE c) AS foo on(foo.id = a);
+DEBUG:  recursively planning right side of the left join since the outer side is a recurring rel
+DEBUG:  recursively planning the distributed subquery since it is part of a distributed join node that is outer joined with a recurring rel
+ERROR:  cannot perform a lateral outer join when a distributed subquery references a JSON_TABLE
+-- JSON_TABLE cannot be on the FROM clause alone
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (json_id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text)) as foo
+WHERE b >
+  (SELECT count(*)
+   FROM my_films WHERE id = foo.a);
+ERROR:  correlated subqueries are not supported when the FROM clause contains JSON_TABLE
+-- we can recursively plan json_tables on set operations
+(SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY))  ORDER BY id ASC LIMIT 1)
+UNION
+(SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY)) ORDER BY id ASC LIMIT 1)
+UNION
+(SELECT id FROM test_table ORDER BY id ASC LIMIT 1);
+DEBUG:  generating subplan XXX_1 for subquery SELECT id FROM JSON_TABLE('[{"a": 10, "b": 20}, {"a": 30, "b": 40}]'::jsonb, '$[*]' AS json_table_path_0 COLUMNS (id FOR ORDINALITY)) ORDER BY id LIMIT 1
+DEBUG:  generating subplan XXX_2 for subquery SELECT id FROM JSON_TABLE('[{"a": 10, "b": 20}, {"a": 30, "b": 40}]'::jsonb, '$[*]' AS json_table_path_0 COLUMNS (id FOR ORDINALITY)) ORDER BY id LIMIT 1
+DEBUG:  push down of limit count: 1
+DEBUG:  generating subplan XXX_3 for subquery SELECT id FROM "json_table".test_table ORDER BY id LIMIT 1
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: SELECT intermediate_result.id FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(id integer) UNION SELECT intermediate_result.id FROM read_intermediate_result('XXX_2'::text, 'binary'::citus_copy_format) intermediate_result(id integer) UNION SELECT intermediate_result.id FROM read_intermediate_result('XXX_3'::text, 'binary'::citus_copy_format) intermediate_result(id bigint)
+ id
+---------------------------------------------------------------------
+  1
+(1 row)
+
+-- LIMIT in subquery not supported when json_table exists
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+JOIN LATERAL
+  (SELECT *
+   FROM my_films WHERE json_table.id = a LIMIT 1) as foo ON (true);
+ERROR:  cannot push down this subquery
+DETAIL:  Limit clause is currently unsupported when a lateral subquery references a column from a JSON_TABLE
+RESET client_min_messages;
+-- test some utility functions on the target list & where clause
+select jsonb_path_exists(js, '$.favorites') from my_films;
+ jsonb_path_exists
+---------------------------------------------------------------------
+ t
+ t
+(2 rows)
+
+select bool_and(JSON_EXISTS(js, '$.favorites.films.title')) from my_films;
+ bool_and
+---------------------------------------------------------------------
+ t
+(1 row)
+
+SELECT count(*) FROM my_films WHERE jsonb_path_exists(js, '$.favorites');
+ count
+---------------------------------------------------------------------
+     2
+(1 row)
+
+SELECT count(*) FROM my_films WHERE jsonb_path_exists(js, '$.favorites');
+ count
+---------------------------------------------------------------------
+     2
+(1 row)
+
+SELECT count(*) FROM my_films WHERE JSON_EXISTS(js, '$.favorites.films.title');
+ count
+---------------------------------------------------------------------
+     2
+(1 row)
+
+-- check constraint with json_exists
+create table user_profiles (
+    id bigserial,
+    addresses jsonb,
+    anyjson  jsonb,
+    check (json_exists( addresses, '$.main' ))
+);
+select create_distributed_table('user_profiles', 'id');
+ create_distributed_table
+---------------------------------------------------------------------
+
+(1 row)
+
+insert into user_profiles (addresses) VALUES (JSON_SCALAR('1'));
+ERROR:  new row for relation "user_profiles_1687008" violates check constraint "user_profiles_addresses_check"
+DETAIL:  Failing row contains (1, "1", null).
+CONTEXT:  while executing command on localhost:xxxxx
+insert into user_profiles (addresses) VALUES ('{"main":"value"}');
+-- we cannot insert because WITH UNIQUE KEYS
+insert into user_profiles (addresses) VALUES (JSON ('{"main":"value", "main":"value"}' WITH UNIQUE KEYS));
+ERROR:  duplicate JSON object key value
+-- we can insert with
+insert into user_profiles (addresses) VALUES (JSON ('{"main":"value", "main":"value"}' WITHOUT UNIQUE KEYS)) RETURNING *;
+ id |     addresses     | anyjson
+---------------------------------------------------------------------
+  4 | {"main": "value"} |
+(1 row)
+
+TRUNCATE user_profiles;
+INSERT INTO user_profiles (anyjson) VALUES ('12'), ('"abc"'), ('[1,2,3]'), ('{"a":12}');
+select anyjson, anyjson is json array as json_array, anyjson is json object as json_object, anyjson is json scalar as json_scalar,
+anyjson is json with UNIQUE keys
+from user_profiles WHERE anyjson IS NOT NULL ORDER BY 1;
+  anyjson  | json_array | json_object | json_scalar | ?column?
+---------------------------------------------------------------------
+ "abc"     | f          | f           | t           | t
+ 12        | f          | f           | t           | t
+ [1, 2, 3] | t          | f           | f           | t
+ {"a": 12} | f          | t           | f           | t
+(4 rows)
+
+-- use json_query
+SELECT i,
+       json_query('[{"x": "aaa"},{"x": "bbb"},{"x": "ccc"}]'::JSONB, '$[$i].x' passing id AS i RETURNING text omit quotes)
+FROM generate_series(0, 3) i
+JOIN my_films ON(id = i);
+ i | json_query
+---------------------------------------------------------------------
+ 1 | bbb
+ 2 | ccc
+(2 rows)
+
+-- we can use JSON_TABLE in modification queries as well
+-- use log level such that we can see trace changes
+SET client_min_messages TO DEBUG1;
+--the JSON_TABLE subquery is recursively planned
+UPDATE test_table SET VALUE = 'XXX' FROM(
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt) as foo  WHERE foo.id = test_table.id;
+DEBUG:  generating subplan XXX_1 for subquery SELECT jt.id, jt.kind, jt.title, jt.director FROM "json_table".my_films, LATERAL JSON_TABLE(my_films.js, '$."favorites"[*]' AS json_table_path_0 COLUMNS (id FOR ORDINALITY, kind text PATH '$."kind"', NESTED PATH '$."films"[*]' AS json_table_path_1 COLUMNS (title text PATH '$."title"', director text PATH '$."director"'))) jt
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE "json_table".test_table SET value = 'XXX'::text FROM (SELECT intermediate_result.id, intermediate_result.kind, intermediate_result.title, intermediate_result.director FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(id integer, kind text, title text, director text)) foo WHERE (foo.id OPERATOR(pg_catalog.=) test_table.id)
+-- Subquery with JSON table can be pushed down because two distributed tables
+-- in the query are joined on distribution column
+UPDATE test_table SET VALUE = 'XXX' FROM (
+SELECT my_films.id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt) as foo  WHERE foo.id = test_table.id;
+-- we can pushdown with CTEs as well
+WITH json_cte AS
+(SELECT my_films.id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt)
+UPDATE test_table SET VALUE = 'XYZ' FROM json_cte
+ WHERE json_cte.id = test_table.id;
+ -- we can recursively with CTEs as well
+WITH json_cte AS
+(SELECT my_films.id as film_id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+      id FOR ORDINALITY,
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt ORDER BY jt.id LIMIT 1)
+UPDATE test_table SET VALUE = 'XYZ' FROM json_cte
+ WHERE json_cte.film_id = test_table.id;
+DEBUG:  generating subplan XXX_1 for CTE json_cte: SELECT my_films.id AS film_id, jt.kind, jt.id, jt.title, jt.director FROM "json_table".my_films, LATERAL JSON_TABLE(my_films.js, '$."favorites"[*]' AS json_table_path_0 COLUMNS (kind text PATH '$."kind"', NESTED PATH '$."films"[*]' AS json_table_path_1 COLUMNS (id FOR ORDINALITY, title text PATH '$."title"', director text PATH '$."director"'))) jt ORDER BY jt.id LIMIT 1
+DEBUG:  push down of limit count: 1
+DEBUG:  Plan XXX query after replacing subqueries and CTEs: UPDATE "json_table".test_table SET value = 'XYZ'::text FROM (SELECT intermediate_result.film_id, intermediate_result.kind, intermediate_result.id, intermediate_result.title, intermediate_result.director FROM read_intermediate_result('XXX_1'::text, 'binary'::citus_copy_format) intermediate_result(film_id bigint, kind text, id integer, title text, director text)) json_cte WHERE (json_cte.film_id OPERATOR(pg_catalog.=) test_table.id)
+-- Should succeed (JSON arguments are passed to root and nested paths)
+SELECT *
+FROM
+	generate_series(1, 4) x,
+	generate_series(1, 3) y,
+	JSON_TABLE(jsonb
+		'[[1,2,3],[2,3,4,5],[3,4,5,6]]',
+		'strict $[*] ? (@[*] < $x)'
+		PASSING x AS x, y AS y
+		COLUMNS (
+			y text FORMAT JSON PATH '$',
+			NESTED PATH 'strict $[*] ? (@ >= $y)'
+			COLUMNS (
+				z int PATH '$'
+			)
+		)
+	) jt ORDER BY 4,1,2,3;
+ x | y |      y       | z
+---------------------------------------------------------------------
+ 2 | 1 | [1, 2, 3]    | 1
+ 3 | 1 | [1, 2, 3]    | 1
+ 4 | 1 | [1, 2, 3]    | 1
+ 2 | 1 | [1, 2, 3]    | 2
+ 2 | 2 | [1, 2, 3]    | 2
+ 3 | 1 | [1, 2, 3]    | 2
+ 3 | 1 | [2, 3, 4, 5] | 2
+ 3 | 2 | [1, 2, 3]    | 2
+ 3 | 2 | [2, 3, 4, 5] | 2
+ 4 | 1 | [1, 2, 3]    | 2
+ 4 | 1 | [2, 3, 4, 5] | 2
+ 4 | 2 | [1, 2, 3]    | 2
+ 4 | 2 | [2, 3, 4, 5] | 2
+ 2 | 1 | [1, 2, 3]    | 3
+ 2 | 2 | [1, 2, 3]    | 3
+ 2 | 3 | [1, 2, 3]    | 3
+ 3 | 1 | [1, 2, 3]    | 3
+ 3 | 1 | [2, 3, 4, 5] | 3
+ 3 | 2 | [1, 2, 3]    | 3
+ 3 | 2 | [2, 3, 4, 5] | 3
+ 3 | 3 | [1, 2, 3]    | 3
+ 3 | 3 | [2, 3, 4, 5] | 3
+ 4 | 1 | [1, 2, 3]    | 3
+ 4 | 1 | [2, 3, 4, 5] | 3
+ 4 | 1 | [3, 4, 5, 6] | 3
+ 4 | 2 | [1, 2, 3]    | 3
+ 4 | 2 | [2, 3, 4, 5] | 3
+ 4 | 2 | [3, 4, 5, 6] | 3
+ 4 | 3 | [1, 2, 3]    | 3
+ 4 | 3 | [2, 3, 4, 5] | 3
+ 4 | 3 | [3, 4, 5, 6] | 3
+ 3 | 1 | [2, 3, 4, 5] | 4
+ 3 | 2 | [2, 3, 4, 5] | 4
+ 3 | 3 | [2, 3, 4, 5] | 4
+ 4 | 1 | [2, 3, 4, 5] | 4
+ 4 | 1 | [3, 4, 5, 6] | 4
+ 4 | 2 | [2, 3, 4, 5] | 4
+ 4 | 2 | [3, 4, 5, 6] | 4
+ 4 | 3 | [2, 3, 4, 5] | 4
+ 4 | 3 | [3, 4, 5, 6] | 4
+ 3 | 1 | [2, 3, 4, 5] | 5
+ 3 | 2 | [2, 3, 4, 5] | 5
+ 3 | 3 | [2, 3, 4, 5] | 5
+ 4 | 1 | [2, 3, 4, 5] | 5
+ 4 | 1 | [3, 4, 5, 6] | 5
+ 4 | 2 | [2, 3, 4, 5] | 5
+ 4 | 2 | [3, 4, 5, 6] | 5
+ 4 | 3 | [2, 3, 4, 5] | 5
+ 4 | 3 | [3, 4, 5, 6] | 5
+ 4 | 1 | [3, 4, 5, 6] | 6
+ 4 | 2 | [3, 4, 5, 6] | 6
+ 4 | 3 | [3, 4, 5, 6] | 6
+(52 rows)
+
+SET client_min_messages TO ERROR;
+DROP SCHEMA json_table CASCADE;
diff --git a/src/test/regress/expected/json_table_0.out b/src/test/regress/expected/json_table_0.out
new file mode 100644
index 00000000000..f8f98b932fc
--- /dev/null
+++ b/src/test/regress/expected/json_table_0.out
@@ -0,0 +1,18 @@
+--
+-- JSON_TABLE
+-- PG17 has added basic JSON_TABLE() functionality
+-- JSON_TABLE() allows JSON data to be converted into a relational view
+-- and thus used, for example, in a FROM clause, like other tabular
+-- data. We treat JSON_TABLE the same as correlated functions (e.g., recurring tuples).
+-- In the end, for multi-shard JSON_TABLE commands, we apply the same
+-- restrictions as reference tables (e.g., cannot perform a lateral outer join
+-- when a distributed subquery references a (reference table)/JSON_TABLE etc.)
+-- Relevant PG commit:
+-- https://github.com/postgres/postgres/commit/de3600452
+--
+SHOW server_version \gset
+SELECT substring(:'server_version', '\d+')::int >= 17 AS server_version_ge_17
+\gset
+\if :server_version_ge_17
+\else
+\q
diff --git a/src/test/regress/multi_schedule b/src/test/regress/multi_schedule
index 0fa54bb384d..2635d0ce815 100644
--- a/src/test/regress/multi_schedule
+++ b/src/test/regress/multi_schedule
@@ -66,7 +66,7 @@ test: pg14
 test: pg15
 test: pg15_jsonpath detect_conn_close
 test: pg16
-test: pg17
+test: pg17 json_table
 test: drop_column_partitioned_table
 test: tableam
 
diff --git a/src/test/regress/sql/json_table.sql b/src/test/regress/sql/json_table.sql
new file mode 100644
index 00000000000..cc7eb237a25
--- /dev/null
+++ b/src/test/regress/sql/json_table.sql
@@ -0,0 +1,341 @@
+--
+-- JSON_TABLE
+-- PG17 has added basic JSON_TABLE() functionality
+-- JSON_TABLE() allows JSON data to be converted into a relational view
+-- and thus used, for example, in a FROM clause, like other tabular
+-- data. We treat JSON_TABLE the same as correlated functions (e.g., recurring tuples).
+-- In the end, for multi-shard JSON_TABLE commands, we apply the same
+-- restrictions as reference tables (e.g., cannot perform a lateral outer join
+-- when a distributed subquery references a (reference table)/JSON_TABLE etc.)
+-- Relevant PG commit:
+-- https://github.com/postgres/postgres/commit/de3600452
+--
+
+SHOW server_version \gset
+SELECT substring(:'server_version', '\d+')::int >= 17 AS server_version_ge_17
+\gset
+\if :server_version_ge_17
+\else
+\q
+\endif
+
+CREATE SCHEMA json_table;
+SET search_path TO json_table;
+
+SET citus.next_shard_id TO 1687000;
+
+CREATE TABLE test_table(id bigserial, value text);
+SELECT create_distributed_table('test_table', 'id');
+INSERT INTO test_table (value) SELECT i::text FROM generate_series(0,100)i;
+
+
+CREATE TABLE my_films(id bigserial, js jsonb);
+SELECT create_distributed_table('my_films', 'id');
+
+INSERT INTO my_films(js) VALUES (
+'{ "favorites" : [
+   { "kind" : "comedy", "films" : [ { "title" : "Bananas", "director" : "Woody Allen"},
+                                    { "title" : "The Dinner Game", "director" : "Francis Veber" } ] },
+   { "kind" : "horror", "films" : [{ "title" : "Psycho", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "thriller", "films" : [{ "title" : "Vertigo", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "drama", "films" : [{ "title" : "Yojimbo", "director" : "Akira Kurosawa" } ] }
+  ] }');
+
+INSERT INTO my_films(js) VALUES (
+'{ "favorites" : [
+   { "kind" : "comedy", "films" : [ { "title" : "Bananas2", "director" : "Woody Allen"},
+                                    { "title" : "The Dinner Game2", "director" : "Francis Veber" } ] },
+   { "kind" : "horror", "films" : [{ "title" : "Psycho2", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "thriller", "films" : [{ "title" : "Vertigo2", "director" : "Alfred Hitchcock" } ] },
+   { "kind" : "drama", "films" : [{ "title" : "Yojimbo2", "director" : "Akira Kurosawa" } ] }
+  ] }');
+
+-- a router query
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+      WHERE my_films.id = 1
+    ORDER BY 1,2,3,4;
+
+-- router query with an explicit LATEREL SUBQUERY
+SELECT sub.*
+FROM my_films,
+     lateral(SELECT * FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                           kind text PATH '$.kind',
+                           NESTED PATH '$.films[*]' COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt) as sub
+WHERE my_films.id = 1;
+
+-- router query with an explicit LATEREL SUBQUERY and LIMIT
+SELECT sub.*
+FROM my_films,
+     lateral(SELECT * FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                           kind text PATH '$.kind',
+                           NESTED PATH '$.films[*]' COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt ORDER BY id DESC LIMIT 1) as sub
+WHERE my_films.id = 1;
+
+-- set it DEBUG1 in case the plan changes
+-- we can see details
+SET client_min_messages TO DEBUG1;
+
+-- a mult-shard query
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+    ORDER BY 1,2,3,4;
+
+-- recursively plan subqueries that has JSON_TABLE
+SELECT count(*) FROM
+(
+ SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt
+    LIMIT 1) as sub_with_json, test_table
+WHERE test_table.id = sub_with_json.id;
+
+
+-- multi-shard query with an explicit LATEREL SUBQUERY
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+   												  kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true)
+    ORDER BY 1,2,3,4;
+
+-- JSON_TABLE can be on the inner part of an outer joion
+SELECT sub.*
+FROM my_films LEFT JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true)
+    ORDER BY 1,2,3,4;
+
+-- we can pushdown this correlated subquery in WHERE clause
+SELECT count(*)
+FROM my_films WHERE
+  (SELECT count(*) > 0
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000);
+
+-- we can pushdown this correlated subquery in SELECT clause
+ SELECT (SELECT count(*) > 0
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt)
+FROM my_films;
+
+-- multi-shard query with an explicit LATEREL SUBQUERY
+-- along with other tables
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) JOIN test_table ON(my_films.id = test_table.id)
+    ORDER BY 1,2,3,4;
+
+-- non-colocated join fails
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) JOIN test_table ON(my_films.id != test_table.id)
+    ORDER BY 1,2,3,4;
+
+-- JSON_TABLE can be in the outer part of the join
+-- as long as there is a distributed table
+SELECT sub.*
+FROM my_films JOIN
+     lateral
+  (SELECT *
+   FROM JSON_TABLE (js, '$.favorites[*]' COLUMNS (id FOR ORDINALITY,
+                            kind text PATH '$.kind', NESTED PATH '$.films[*]'
+                            COLUMNS (title text PATH '$.title', director text PATH '$.director'))) AS jt
+   LIMIT 1000) AS sub ON (true) LEFT JOIN test_table ON(my_films.id = test_table.id)
+    ORDER BY 1,2,3,4;
+
+-- JSON_TABLE can be on the outer side of the join
+-- We support outer joins where the outer rel is a recurring one
+-- and the inner one is a non-recurring one if we don't reference the outer from the inner
+-- https://github.com/citusdata/citus/pull/6512
+
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+LEFT JOIN LATERAL
+  (SELECT *
+   FROM my_films) AS foo on(foo.id = a);
+
+-- However we don't support
+-- when we reference the JSON_TABLE from the non-recurring distributed table subquery
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (json_id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+LEFT JOIN LATERAL
+  (SELECT *
+   FROM my_films WHERE id::text LIKE c) AS foo on(foo.id = a);
+
+-- JSON_TABLE cannot be on the FROM clause alone
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (json_id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text)) as foo
+WHERE b >
+  (SELECT count(*)
+   FROM my_films WHERE id = foo.a);
+
+-- we can recursively plan json_tables on set operations
+(SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY))  ORDER BY id ASC LIMIT 1)
+UNION
+(SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY)) ORDER BY id ASC LIMIT 1)
+UNION
+(SELECT id FROM test_table ORDER BY id ASC LIMIT 1);
+
+-- LIMIT in subquery not supported when json_table exists
+SELECT *
+FROM json_table('[{"a":10,"b":20},{"a":30,"b":40}]'::JSONB, '$[*]'
+               COLUMNS (id FOR  ORDINALITY, column_a int4 PATH '$.a', column_b int4 PATH '$.b', a int4, b int4, c text))
+JOIN LATERAL
+  (SELECT *
+   FROM my_films WHERE json_table.id = a LIMIT 1) as foo ON (true);
+
+RESET client_min_messages;
+
+-- test some utility functions on the target list & where clause
+select jsonb_path_exists(js, '$.favorites') from my_films;
+select bool_and(JSON_EXISTS(js, '$.favorites.films.title')) from my_films;
+SELECT count(*) FROM my_films WHERE jsonb_path_exists(js, '$.favorites');
+SELECT count(*) FROM my_films WHERE jsonb_path_exists(js, '$.favorites');
+SELECT count(*) FROM my_films WHERE JSON_EXISTS(js, '$.favorites.films.title');
+
+-- check constraint with json_exists
+create table user_profiles (
+    id bigserial,
+    addresses jsonb,
+    anyjson  jsonb,
+    check (json_exists( addresses, '$.main' ))
+);
+select create_distributed_table('user_profiles', 'id');
+insert into user_profiles (addresses) VALUES (JSON_SCALAR('1'));
+insert into user_profiles (addresses) VALUES ('{"main":"value"}');
+
+-- we cannot insert because WITH UNIQUE KEYS
+insert into user_profiles (addresses) VALUES (JSON ('{"main":"value", "main":"value"}' WITH UNIQUE KEYS));
+
+-- we can insert with
+insert into user_profiles (addresses) VALUES (JSON ('{"main":"value", "main":"value"}' WITHOUT UNIQUE KEYS)) RETURNING *;
+
+TRUNCATE user_profiles;
+INSERT INTO user_profiles (anyjson) VALUES ('12'), ('"abc"'), ('[1,2,3]'), ('{"a":12}');
+select anyjson, anyjson is json array as json_array, anyjson is json object as json_object, anyjson is json scalar as json_scalar,
+anyjson is json with UNIQUE keys
+from user_profiles WHERE anyjson IS NOT NULL ORDER BY 1;
+
+-- use json_query
+SELECT i,
+       json_query('[{"x": "aaa"},{"x": "bbb"},{"x": "ccc"}]'::JSONB, '$[$i].x' passing id AS i RETURNING text omit quotes)
+FROM generate_series(0, 3) i
+JOIN my_films ON(id = i);
+
+-- we can use JSON_TABLE in modification queries as well
+
+-- use log level such that we can see trace changes
+SET client_min_messages TO DEBUG1;
+
+--the JSON_TABLE subquery is recursively planned
+UPDATE test_table SET VALUE = 'XXX' FROM(
+SELECT jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   id FOR ORDINALITY,
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt) as foo  WHERE foo.id = test_table.id;
+
+-- Subquery with JSON table can be pushed down because two distributed tables
+-- in the query are joined on distribution column
+UPDATE test_table SET VALUE = 'XXX' FROM (
+SELECT my_films.id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt) as foo  WHERE foo.id = test_table.id;
+
+-- we can pushdown with CTEs as well
+WITH json_cte AS
+(SELECT my_films.id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt)
+UPDATE test_table SET VALUE = 'XYZ' FROM json_cte
+ WHERE json_cte.id = test_table.id;
+
+ -- we can recursively with CTEs as well
+WITH json_cte AS
+(SELECT my_films.id as film_id, jt.* FROM
+ my_films,
+ JSON_TABLE ( js, '$.favorites[*]' COLUMNS (
+   kind text PATH '$.kind',
+   NESTED PATH '$.films[*]' COLUMNS (
+      id FOR ORDINALITY,
+     title text PATH '$.title',
+     director text PATH '$.director'))) AS jt ORDER BY jt.id LIMIT 1)
+UPDATE test_table SET VALUE = 'XYZ' FROM json_cte
+ WHERE json_cte.film_id = test_table.id;
+
+-- Should succeed (JSON arguments are passed to root and nested paths)
+SELECT *
+FROM
+	generate_series(1, 4) x,
+	generate_series(1, 3) y,
+	JSON_TABLE(jsonb
+		'[[1,2,3],[2,3,4,5],[3,4,5,6]]',
+		'strict $[*] ? (@[*] < $x)'
+		PASSING x AS x, y AS y
+		COLUMNS (
+			y text FORMAT JSON PATH '$',
+			NESTED PATH 'strict $[*] ? (@ >= $y)'
+			COLUMNS (
+				z int PATH '$'
+			)
+		)
+	) jt ORDER BY 4,1,2,3;
+
+SET client_min_messages TO ERROR;
+DROP SCHEMA json_table CASCADE;